@dhyasama/totem-models 9.64.1 → 9.66.0

package/index.js

@@ -56,6 +56,7 @@ var bootstrap = function(mongoose, config) {
   require('./lib/Interaction.js')(mongoose, config);
   require('./lib/Investment.js')(mongoose, config);
   require('./lib/List.js')(mongoose, config);
+  require('./lib/LimitedPartnerCampaign.js')(mongoose, config);
   require('./lib/LimitedPartnerContactGroup.js')(mongoose, config);
   require('./lib/LimitedPartnerCommunication.js')(mongoose, config);
   require('./lib/Message.js')(mongoose, config);

package/lib/LimitedPartnerCampaign.js

@@ -0,0 +1,151 @@
+'use strict';
+
+const _ = require('underscore');
+
+module.exports = function(mongoose, config) {
+
+  const Schema = mongoose.Schema;
+
+  const LimitedPartnerCampaign = new Schema({
+
+    // name of the campaign, e.g., "2022 Annual Audit"
+    name: { type: String, trim: true, required: true },
+
+    // customer sending this communication
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
+
+    // date and time to send
+    sendOn: { type: Date, required: true },
+
+    // email subject
+    subject: { type: String, trim: true, required: true },
+
+    // email body
+    body: { type: String, trim: true, required: true },
+
+    // job was added to queue to send emails
+    sentToQueue: { type: Boolean, required: true, default: false },
+
+  });
+
+  LimitedPartnerCampaign.statics.getById = function getById(campaignId, customerId, options, cb) {
+
+    const self = this;
+
+    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); }
+    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
+    });
+
+    query.exec(cb);
+
+  };
+
+  // Scheduled but not sent and now isn't the time
+  LimitedPartnerCampaign.statics.getFuture = function getFuture(customerId, options, cb) {
+
+    const self = this;
+    const now = new Date();
+
+    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,
+      sentToQueue: false,
+      sendOn: { $gte: now }
+    });
+
+    query.exec(cb);
+
+  };
+
+  // Scheduled and not yet sent but now is the time
+  // 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) {
+
+    const self = this;
+    const now = new Date();
+
+    if (!cb) { throw new Error('cb is required'); }
+
+    let query = self.find({
+      sentToQueue: false,
+      sendOn: { $lte: now }
+    });
+
+    query.exec(cb);
+
+  };
+
+  // Already sent
+  LimitedPartnerCampaign.statics.getPrevious = function getPrevious(customerId, options, cb) {
+
+    const self = this;
+
+    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); }
+
+    // No need to check send on. If sentToQueue then safe to assume sendOn is in the past.
+
+    const query = self.find({
+      customer: customerId,
+      sentToQueue: true
+    });
+
+    query.exec(cb);
+
+  };
+
+  LimitedPartnerCampaign.statics.remove = function remove(campaignId, customerId, options, cb) {
+
+    const self = this;
+
+    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); }
+    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.findOneAndRemove({
+      id: campaignId,
+      customer: customerId
+    });
+
+    query.exec(cb);
+
+    // remove associated limited partner communications at the business logic layer
+
+  };
+
+  LimitedPartnerCampaign.statics.upsert = function upsert(doc, options, cb) {
+
+    if (!doc) { return cb(new Error('doc is required'), null); }
+
+    doc.save(cb);
+
+  };
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  LimitedPartnerCampaign.set('usePushEach', true);
+  LimitedPartnerCampaign.set('toJSON', { virtuals: true });
+  LimitedPartnerCampaign.set('autoIndex', false);
+  LimitedPartnerCampaign.set('usePushEach', true);
+
+  LimitedPartnerCampaign.on('index', function(err) { console.log('error building LimitedPartnerCampaign indexes: ' + err); });
+
+  mongoose.model('LimitedPartnerCampaign', LimitedPartnerCampaign);
+
+};

package/lib/LimitedPartnerCommunication.js

@@ -6,81 +6,80 @@ module.exports = function(mongoose, config) {
 
   const LimitedPartnerCommunication = new Schema({
 
-    // name of the campaign, e.g., "2022 Annual Audit"
-    campaign: { type: String, trim: true, required: true },
+    // campaign this communication is part of
+    campaign: { type: Schema.ObjectId, ref: 'LimitedPartnerCampaign', required: true },
 
-    // customer sending this communication
-    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
+    // the lp it's for
+    limitedPartner: { type: Schema.ObjectId, ref: 'LimitedPartner', required: true },
 
-    // date and time to send
-    sendOn: { type: Date, required: true },
+    // email of recipient from the lp
+    email: { type: String, trim: true, required: true },
 
-    // email content
-    email: {
+    // attach document to email (only option currently supported)
+    attachToEmail: { type: Boolean, required: true, default: true },
 
-      // email subject
-      subject: { type: String, trim: true, required: true },
+    // job was added to queue to send email
+    sentToQueue: { type: Boolean, required: true, default: false },
 
-      // email body
-      body: { type: String, trim: true, required: true },
+    // when email was sent
+    sentOn: { type: Date, required: false },
 
-    },
+    // postmark reference
+    postmarkMessageId: { type: String, trim: true, required: false },
 
-    // whether the task has been sent to the queue
-    sentToQueue: { type: Boolean, default: false },
+    // email tracking via postmark
+    emailStatus: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked'], required: false },
 
-    limitedPartners: [{
+    // the documents included in this communication
+    documents: [{
 
-      // the lp it's for
-      limitedPartner: { type: Schema.ObjectId, ref: 'LimitedPartner', required: true },
+      fileName: { type: String, trim: true, required: true },
 
-      // attach documents to email (only option currently supported)
-      attachToEmail: { type: Boolean, required: true, default: true },
+      // file type
+      contentType: { type: String, trim: true, required: true },
 
-      // the documents included in this communication
-      documents: [{
+      // file size
+      contentLength: { type: String, trim: true, required: true },
 
-        fileName: { type: String, trim: true, required: true },
+      // where to find in s3
+      s3: {
+        bucket: { type: String, required: true, trim: true },
+        key: { type: String, required: true, trim: true }
+      }
 
-        // file type
-        contentType: { type: String, trim: true, required: true },
+    }]
 
-        // file size
-        contentLength: { type: String, trim: true, required: true },
+  });
 
-        // where to find in s3
-        s3: {
-          bucket: { type: String, required: true, trim: true },
-          key: { type: String, required: true, trim: true }
-        }
+  LimitedPartnerCommunication.statics.getByCampaign = function getByCampaign(campaignId, options, cb) {
 
-      }],
-      
-      notifications: [{
-        sendTo: { type: String, trim: true },
-        sentOn: { type: Date, required: false },
-        postmarkMessageId: { type: String, trim: true },
-        status: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked']}
-      }],
+    const self = this;
 
-    }]
+    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
+    });
 
-  // So we can put these on lp pages
-  LimitedPartnerCommunication.statics.getForLimitedPartner = function getForLimitedPartner(lpid, options, cb) {
+    query.exec(cb);
+
+  };
+
+  // So we can put these on person pages
+  LimitedPartnerCommunication.statics.getByEmail = function getByEmail(email, options, cb) {
 
     const self = this;
 
     if (!cb) { throw new Error('cb is required'); }
-    if (!lpid) { return cb(new Error('lpid is required'), null); }
-    if (!mongoose.Types.ObjectId.isValid(lpid)) { return cb(new Error('lpid is not a valid ObjectId'), null); }
+    if (!email) { return cb(new Error('email is required'), null); }
     if (!options) { return cb(new Error('options is required'), null); }
     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({
-      'limitedPartners.limitedPartner': lpid,
+      email: email,
       customer: options.CUSTOMER_ID
     });
 
@@ -88,88 +87,77 @@ module.exports = function(mongoose, config) {
 
   };
 
-  // Get all communications that haven't been sent but are scheduled to go
-  // Scheduled worker jobs will use this and add them to the queue to send
-  LimitedPartnerCommunication.statics.getReadyToSend = function getReadyToSend(options, cb) {
+  // So we can put these on lp pages
+  LimitedPartnerCommunication.statics.getForLimitedPartner = function getForLimitedPartner(lpid, options, cb) {
 
     const self = this;
-    const now = new Date();
 
     if (!cb) { throw new Error('cb is required'); }
+    if (!lpid) { return cb(new Error('lpid is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(lpid)) { return cb(new Error('lpid is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    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({
-      sentToQueue: false,
-      sendOn: { $lte: now }
+      limitedPartner: lpid,
+      customer: options.CUSTOMER_ID
     });
 
     query.exec(cb);
 
   };
 
-  // For the "Historical" page
-  LimitedPartnerCommunication.statics.getSentForCustomer = function getSentForCustomer(customerId, options, cb) {
+  // Get all communications that haven't been sent but are scheduled to go
+  // Scheduled worker jobs will use this and add them to the queue to send
+  LimitedPartnerCommunication.statics.getReadyToSend = function getReadyToSend(options, cb) {
 
     const self = this;
+    const now = new Date();
 
     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,
-      sentOn: { $ne: null }
+      sentToQueue: false,
+      sendOn: { $lte: now }
     });
 
+    query.populate('campaign');
+
     query.exec(cb);
 
   };
 
-  // For the "Scheduled" page
-  LimitedPartnerCommunication.statics.getUnsentForCustomer = function getUnsentForCustomer(customerId, options, cb) {
+  // Remove all the docs associated with a campaign
+  LimitedPartnerCommunication.statics.removeByCampaign = function removeByCampaign(campaignId, options, cb) {
 
     const self = this;
 
     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); }
+    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({
-      customer: customerId,
-      sentOn: null
+    const query = self.deleteMany({
+      campaign: campaignId
     });
 
     query.exec(cb);
 
   };
 
-  LimitedPartnerCommunication.statics.delete = function(id, options, cb) {
+  LimitedPartnerCommunication.statics.removeById = function removeById(id, options, cb) {
 
-    let self = this;
+    const self = this;
 
     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); }
-    if (!options) { return cb(new Error('options is required'), null); }
-    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); }
-
-    // Not strictly necessary but provides verification that the document being deleted belongs to the customer doing the deleting
 
-    let query = self.findOne({
-      '_id': id,
-      'customer': options.CUSTOMER_ID
+    const query = self.findByIdAndRemove({
+      id: id
     });
 
-    query.exec(function(err, doc) {
-
-      if (err) return cb(err, null);
-      else if (!doc) return cb(null, null);
-
-      // No population so no need to scrub
-
-      doc.remove(cb);
-
-    });
+    query.exec(cb);
 
   };
 
@@ -195,4 +183,4 @@ module.exports = function(mongoose, config) {
 
   mongoose.model('LimitedPartnerCommunication', LimitedPartnerCommunication);
 
-};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhyasama/totem-models",
-  "version": "9.64.1",
+  "version": "9.66.0",
   "author": "Jason Reynolds",
   "license": "UNLICENSED",
   "description": "Models for Totem platform",