@dhyasama/totem-models 9.54.0 → 9.55.0

package/lib/LimitedPartnerCommunication.js

@@ -0,0 +1,161 @@
+'use strict';
+
+module.exports = function(mongoose, config) {
+
+  const
+
+    Schema = mongoose.Schema,
+    _ = require('underscore');
+
+  const LimitedPartnerCommunication = new Schema({
+
+    // name of the communication, 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 individual emails
+    sentToQueue: { type: Boolean, required: true, default: false },
+
+    documents: [{
+
+      // the lp this doc is for
+      limitedPartner: { type: Schema.ObjectId, ref: 'LimitedPartner', required: true },
+
+      // unique id for this document
+      uuid: { type: String, trim: true, required: true },
+
+      // email of recipient for notification and access
+      email: { type: String, trim: true, required: true },
+
+      // attach document to email
+      attachToEmail: { type: Boolean, required: true, default: false },
+
+      // when notification was sent
+      sentOn: { type: Date, required: false },
+
+      // email reference
+      postmarkMessageId: { type: String, trim: true, required: false },
+
+      emailStatus: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked'], required: false },
+
+      // OTP used to access the document
+      oneTimePassword: { type: String, trim: true, required: true },
+
+      // OTP only good for limited time and then a new one must be requested
+      oneTimePasswordExpiration: { type: Date, trim: true, required: true },
+
+      fileName: { type: String, trim: true, required: 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 }
+      }
+
+    }]
+
+  });
+
+  // Get a full communication for a customer
+  // Use 1: Customer can use while setting up or viewing a batch
+  // Use 2: Also, use this to get doc when an lp requests it. Use comm id from url to get it here,
+  // then in BLL use the uuid from url to select the doc. At that point, we can serve up
+  // the doc or go through the OTP process.
+  LimitedPartnerCommunication.statics.getById = function getById(id, options, cb) {
+
+    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); }
+
+    let query = self.findOne({
+      '_id': id,
+      'customer': options.CUSTOMER_ID
+    });
+
+    query.populate('customer');
+    query.populate('documents.limitedPartner', 'name');
+
+    query.exec(cb);
+
+  };
+
+  // Get all communications for a customer
+  LimitedPartnerCommunication.statics.getForCustomer = function getForCustomer(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); }
+
+    let query = self.find({
+      'customer': customerId
+    });
+
+    query.exec(cb);
+
+  };
+
+  // Get all batches that haven't been sent but are scheduled to go
+  // Use case 1: Worker pulls this list and sends docs to lps
+  LimitedPartnerCommunication.statics.getReadyToSend = function getReadyToSend(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);
+
+  };
+
+  LimitedPartnerCommunication.statics.upsert = function upsert(doc, options, cb) {
+
+    if (!doc) { return cb(new Error('doc is required'), null); }
+
+    doc.save(cb);
+
+  };
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  LimitedPartnerCommunication.set('usePushEach', true);
+  LimitedPartnerCommunication.set('toJSON', { virtuals: true });
+  LimitedPartnerCommunication.set('autoIndex', false);
+  LimitedPartnerCommunication.set('usePushEach', true);
+
+  LimitedPartnerCommunication.on('index', function(err) { console.log('error building LimitedPartnerCommunication indexes: ' + err); });
+
+  mongoose.model('LimitedPartnerCommunication', LimitedPartnerCommunication);
+
+};

package/lib/LimitedPartnerContactGroup.js

@@ -0,0 +1,90 @@
+'use strict';
+
+module.exports = function(mongoose, config) {
+
+  const Schema = mongoose.Schema;
+
+  const LimitedPartnerContactGroup = new Schema({
+
+    // name of group, e.g., "K1" or "Audit"
+    name: { type: String, trim: true, required: true },
+
+    // customer the group belongs to
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
+
+    // emails for each lp in the group
+    contacts: [{
+
+      // the lp
+      limitedPartner: { type: Schema.ObjectId, ref: 'LimitedPartner', required: true },
+
+      // one or more emails to send to
+      emails: [{ type: String, trim: true, required: true }]
+
+    }]
+
+  });
+
+  // Get a contact group
+  LimitedPartnerContactGroup.statics.getById = function (id, options, cb) {
+
+    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); }
+
+    let query = self.findOne({
+      '_id': id,
+      'customer': options.CUSTOMER_ID
+    });
+
+    query.populate('contacts.limitedPartner', 'name');
+
+    query.exec(cb);
+
+  };
+
+  // Get all contact groups for a customer
+  LimitedPartnerContactGroup.statics.getForCustomer = function (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); }
+
+    let query = self.find({
+      'customer': customerId
+    });
+
+    query.exec(cb);
+
+  };
+
+  LimitedPartnerContactGroup.statics.upsert = function upsert(doc, options, cb) {
+
+    if (!doc) { return cb(new Error('doc is required'), null); }
+
+    doc.save(cb);
+
+  };
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  LimitedPartnerContactGroup.set('usePushEach', true);
+  LimitedPartnerContactGroup.set('toJSON', { virtuals: true });
+  LimitedPartnerContactGroup.set('autoIndex', false);
+  LimitedPartnerContactGroup.set('usePushEach', true);
+
+  LimitedPartnerContactGroup.on('index', function(err) { console.log('error building LimitedPartnerContactGroup indexes: ' + err); });
+
+  mongoose.model('LimitedPartnerContactGroup', LimitedPartnerContactGroup);
+
+};

package/lib/Round.js

@@ -112,7 +112,9 @@ module.exports = function(mongoose, config) {
         logoUrl: rounds[0].organization.logoUrl,
         description: rounds[0].organization.description,
         status: rounds[0].organization.status,
-        websites: websites
+        contact: rounds[0].organization.contact,
+        websites: websites,
+        rounds: rounds
       };
 
       var performance = calculatePerformance(rounds);

package/package.json

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