@dhyasama/totem-models 7.57.0 → 8.0.0

package/lib/Financials.js

@@ -10,7 +10,6 @@
 module.exports = function(mongoose, config) {
 
   var Schema = mongoose.Schema;
-  var async = require('async');
   var _ = require('underscore');
   var moment = require('moment');
 
@@ -28,6 +27,8 @@ module.exports = function(mongoose, config) {
 
       uuid: { type: String },
 
+      campaignId: { type: String },
+
       managedServices: { type: Boolean, default: false, required: true },
 
       status: { type: String },
@@ -114,18 +115,16 @@ module.exports = function(mongoose, config) {
 
       submittedOn: { type: Date, index: false },
       submittedBy: { type: String, trim: true },
-
       reviewedOn: { type: Date, index: false },
-      rejection: { type: String, trim: true },
 
       notifications: {
 
         company: {
 
-          sendTo: [{
+          sendTo: {
             email: { type: String, trim: true },
             name: { type: String, trim: true }
-          }],
+          },
 
           initial: {
             sendOn: { type: Date, required: false },
@@ -134,18 +133,17 @@ module.exports = function(mongoose, config) {
             status: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked']}
           },
 
-          reminders: [{
+          reminder: {
             sendOn: { type: Date, required: false },
             sentOn: { type: Date, required: false },
             postmarkMessageId: { type: String, trim: true },
             status: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked']}
-          }],
+          },
 
-          rejections: [{
-            sendOn: { type: Date, required: false },
-            sentOn: { type: Date, required: false },
+          history: [{
+            email: { type: String, trim: true },
             postmarkMessageId: { type: String, trim: true },
-            status: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked']}            
+            status: { type: String, enum: [null, 'Sent', 'Bounced', 'Delivered', 'Opened', 'Clicked']}
           }]
 
         },
@@ -182,6 +180,8 @@ module.exports = function(mongoose, config) {
 
   });
 
+
+
   ///////////////////////////////////////////////////////////////////////////////////////
   // METHODS
   // Methods operate on a single document
@@ -196,9 +196,9 @@ module.exports = function(mongoose, config) {
 
   Financials.statics.getByOrg = function getByOrg(customerId, orgId, cb) {
 
-    var self = this;
+    let self = this;
 
-    var query = self.findOne({
+    let query = self.findOne({
       'customer': customerId,
       'organization': orgId
     }).populate({
@@ -206,15 +206,34 @@ module.exports = function(mongoose, config) {
       match: { customer: customerId }
     });
 
+    // No need to scrub because population matched on customer id
+
+    query.exec(cb);
+
+  };
+
+  Financials.statics.getByPostmarkMessageId = function getByPostmarkMessageId(postmarkMessageId, cb) {
+
+    let self = this;
+
+    let query = self.findOne({
+      $or: [
+        { 'snapshots.notifications.company.initial.postmarkMessageId': postmarkMessageId },
+        { 'snapshots.notifications.company.reminder.postmarkMessageId': postmarkMessageId }
+      ]
+    });
+
+    // No population so no need to scrub
+
     query.exec(cb);
 
   };
 
   Financials.statics.getByUUID = function getByUUID(customerId, uuid, cb) {
 
-    var self = this;
+    let self = this;
 
-    var query = self.findOne({
+    let query = self.findOne({
       'customer': customerId,
       'snapshots.uuid': uuid
     });
@@ -226,146 +245,114 @@ module.exports = function(mongoose, config) {
       match: { customer: customerId }
     });
 
+    // No need to scrub because population matched on customer id
+
     query.exec(cb);
 
   };
 
-  Financials.statics.getByPostmarkMessageId = function getByPostmarkMessageId(postmarkMessageId, cb) {
+  Financials.statics.getForCampaign = function getForCampaign(customerId, cb) {
 
-    var self = this;
+    let self = this;
 
-    var query = self.findOne({
-      $or: [
-        { 'snapshots.notifications.company.initial.postmarkMessageId': postmarkMessageId },
-        { 'snapshots.notifications.company.reminders.postmarkMessageId': postmarkMessageId },
-        { 'snapshots.notifications.company.rejections.postmarkMessageId': postmarkMessageId },
-      ]
+    let query = self.find({
+      'customer': customerId,
+      'notification.contact.exclude': { $ne: true }, // null, false, or non-existing field
+      'notification.contact.email': { $ne: null } // field exists and has a value
     });
 
+    // No population so no need to scrub
+
     query.exec(cb);
 
   };
 
-  Financials.statics.getInitialUUIDsToSend = function getInitialUUIDsToSend(cb) {
+  Financials.statics.getForCustomer = function getForCustomer(customerId, cb) {
 
-    var self = this;
-    var now = new Date();
+    let self = this;
 
-    var query = self.find({
-      'snapshots': {
-        $elemMatch: {
-          'notifications.company.sendTo': { $gt: [] },
-          'notifications.company.initial.sendOn': { $lte: now },
-          'notifications.company.initial.sentOn': null
-        }
-      }
+    let query = self.find({
+      'customer': customerId
     });
 
-    query.exec(function(err, result) {
-
-      if (err) { return cb(err, null); }
-
-      var snapshots = _.pluck(result || [], 'snapshots');
+    // No population so no need to scrub
 
-      snapshots = _.flatten(snapshots);
-
-      snapshots = _.filter(snapshots, function(snapshot) {
-
-        var hasRecipients = snapshot.notifications.company.sendTo.length > 0;
-        var hasUnsentSendOnLessThanNow = snapshot.notifications.company.initial.sendOn < now && !snapshot.notifications.company.initial.sentOn;
-
-        return hasRecipients && hasUnsentSendOnLessThanNow;
-
-      });
-
-      return cb(null, _.pluck(snapshots, 'uuid'));
-
-    });
+    query.exec(cb);
 
   };
 
-  Financials.statics.getReminderUUIDsToSend = function getReminderUUIDsToSend(cb) {
+  Financials.statics.getManagedServicesForReview = function getManagedServicesForReview(customerId, cb) {
 
-    var self = this;
-    var now = new Date();
+    let self = this;
 
-    var query = self.find({
+    let query = self.find({
+      'customer': customerId,
       'snapshots': {
         $elemMatch: {
-          'notifications.company.sendTo': { $gt: [] },
-          'notifications.company.reminders.sendOn': { $lte: now },
-          'notifications.company.reminders.sentOn': null,
-           "$or": [
-            {
-              "submittedOn": null,
-            },
-            {
-              "submittedOn": { $ne: null },
-              "rejection": { $ne: null }
-            }
-          ]
+          'managedServices': true, 
+          'submittedOn': { $ne: null },
+          'reviewedOn': null
         }
       }
     });
 
-    query.exec(function(err, result) {
-
-      if (err) { return cb(err, null); }
+    // No population so no need to scrub
 
-      var snapshots = _.pluck(result || [], 'snapshots');
+    query.exec(function(err, result) {
 
+      let snapshots = _.pluck(result || [], 'snapshots');
       snapshots = _.flatten(snapshots);
 
       snapshots = _.filter(snapshots, function(snapshot) {
 
-        var hasRecipients = snapshot.notifications.company.sendTo.length > 0;
-        var hasUnsentSendOnLessThanNow = _.find(snapshot.notifications.company.reminders, function(reminder) {
-          return reminder.sendOn < now && !reminder.sentOn;
-        });
-        var hasNotBeenSubmitted = !snapshot.submittedOn;
-        var hasBeenRejected = snapshot.submittedOn && snapshot.rejection;
+        let bool = snapshot.managedServices;
+        bool = bool && snapshot.submittedOn;
+        bool = bool && !snapshot.reviewedOn;
 
-        return hasRecipients && hasUnsentSendOnLessThanNow && (hasNotBeenSubmitted || hasBeenRejected);
+        return bool;
 
       });
 
-      return cb(null, _.pluck(snapshots, 'uuid'));
+      if (err) { return cb(err, null); }
+      return cb(null, snapshots);
 
     });
 
   };
 
-  Financials.statics.getRejectionUUIDsToSend = function getRejectionUUIDsToSend(cb) {
+  Financials.statics.getUUIDsToSendInitial = function getUUIDsToSendInitial(cb) {
 
-    var self = this;
-    var now = new Date();
+    let self = this;
+    let now = new Date();
 
-    var query = self.find({
+    let query = self.find({
       'snapshots': {
         $elemMatch: {
-          'notifications.company.sendTo': { $gt: [] },
-          'notifications.company.rejections.sendOn': { $lte: now },
-          'notifications.company.rejections.sentOn': null
+          'notifications.company.sendTo.email': { $ne: null },
+          'notifications.company.initial.sendOn': { $lte: now },
+          'notifications.company.initial.sentOn': null,
+          'submittedOn': null
         }
       }
     });
 
+    // No population so no need to scrub
+
     query.exec(function(err, result) {
 
       if (err) { return cb(err, null); }
 
-      var snapshots = _.pluck(result || [], 'snapshots');
+      let snapshots = _.pluck(result || [], 'snapshots');
 
       snapshots = _.flatten(snapshots);
 
       snapshots = _.filter(snapshots, function(snapshot) {
 
-        var hasRecipients = snapshot.notifications.company.sendTo.length > 0;
-        var hasUnsentSendOnLessThanNow = _.find(snapshot.notifications.company.rejections, function(rejection) {
-          return rejection.sendOn < now && !rejection.sentOn;
-        });
+        let bool = !!snapshot.notifications.company.sendTo.email;
+        bool = bool && snapshot.notifications.company.initial.sendOn < now;
+        bool = bool && !snapshot.notifications.company.initial.sentOn;
 
-        return hasRecipients && hasUnsentSendOnLessThanNow;
+        return bool;
 
       });
 
@@ -375,76 +362,46 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Financials.statics.getForCustomer = function getForCustomer(customerId, cb) {
+  Financials.statics.getUUIDsToSendReminder = function getUUIDsToSendReminder(cb) {
 
-    var self = this;
+    let self = this;
+    let now = new Date();
 
-    var query = self.find({
-      'customer': customerId
-    });
-
-    query.exec(cb);
-
-  };
-
-  Financials.statics.getManagedServicesForReview = function getManagedServicesForReview(customerId, cb) {
-
-    var self = this;
-
-    var query = self.find({
-      'customer': customerId,
+    let query = self.find({
       'snapshots': {
         $elemMatch: {
-          'managedServices': true, 
-          'submittedOn': { $ne: null },
-          'reviewedOn': null
+          'notifications.company.sendTo.email': { $ne: null },
+          'notifications.company.reminder.sendOn': { $lte: now },
+          'notifications.company.reminder.sentOn': null,
+          'submittedOn': null
         }
       }
     });
 
-    query.populate('organization', 'name');
-
-    query.exec(function(err, results) {
-
-      var snapshots = [];
+    // No population so no need to scrub
 
-      _.each(results, function(result) {
-        _.each(result.snapshots, function(snapshot) {
+    query.exec(function(err, result) {
 
-          var isManagedServices = snapshot.managedServices;
-          var isSubmitted = snapshot.submittedOn;
-          var isNotReviewed = !snapshot.reviewedOn;
+      if (err) { return cb(err, null); }
 
-          if(isManagedServices && isSubmitted && isNotReviewed) {
-            snapshots.push({
-              organization: result.organization.name,
-              snapshot: snapshot
-            });
-          }
+      let snapshots = _.pluck(result || [], 'snapshots');
 
-        });
-      });
+      snapshots = _.flatten(snapshots);
 
-      if (err) { return cb(err, null); }
-      return cb(null, snapshots);
+      snapshots = _.filter(snapshots, function(snapshot) {
 
-    });
+        let bool = !!snapshot.notifications.company.sendTo.email;
+        bool = bool && snapshot.notifications.company.reminder.sendOn < now;
+        bool = bool && !snapshot.notifications.company.reminder.sentOn;
 
-  };
+        return bool;
 
-  Financials.statics.getToSend = function getToSend(uuid, cb) {
+      });
 
-    var self = this;
+      return cb(null, _.pluck(snapshots, 'uuid'));
 
-    var query = self.findOne({
-      'snapshots.uuid': uuid
     });
 
-    query.populate('organization', 'name logoUrl');
-    query.populate('customer', 'name logoUrl customer.totemUrl');
-
-    query.exec(cb);
-
   };
 
   Financials.statics.removeCustomerFinancials = function removeCustomerFinancials(customerId, cb) {
@@ -452,7 +409,9 @@ module.exports = function(mongoose, config) {
     // this is only used to wipe out financials created by the google sheet import process
     // we do NOT want to delete any financials submitted via forms generated directly from the app
 
-    var self = this;
+    let self = this;
+
+    // No population so no need to scrub
 
     self
       .update(
@@ -465,6 +424,7 @@ module.exports = function(mongoose, config) {
 
   Financials.statics.upsert = function upsert(financials, cb) {
 
+    if (!cb) { throw new Error('cb is required'); }
     if (!financials) { return cb(new Error('financials is required'), null); }
 
     // Required for mixed types
@@ -481,6 +441,8 @@ module.exports = function(mongoose, config) {
     financials.markModified('investingActivities.breakdown');
     financials.markModified('financingActivities.breakdown');
 
+    // No population so no need to scrub
+
     financials.save(cb);
 
   };
@@ -501,24 +463,17 @@ module.exports = function(mongoose, config) {
 
       if(!snapshot) return;
 
-      var isManagedServices = snapshot.managedServices;
-      var isSubmitted = snapshot.submittedOn;
-      var isReviewed = snapshot.reviewedOn;
-      var isRejected = snapshot.rejection;
-
       // no uuid means the data was captured from the google sheet
-      if((!snapshot.uuid) || (!isManagedServices && isSubmitted) || (isManagedServices && isReviewed)) {
+      if((!snapshot.uuid) || (!snapshot.managedServices && snapshot.submittedOn) || (snapshot.managedServices && snapshot.reviewedOn)) {
         snapshot.status = 'Completed';
         snapshot.action = null;
       }
       
-      else if(snapshot.notifications.company && snapshot.notifications.company.initial && snapshot.notifications.company.initial.sendOn) {
-
-        var latestReminder = _.max(snapshot.notifications.company.reminders, function(r) { return new Date(r.sendOn); });
-
-        var isScheduled = snapshot.notifications.company.initial.sendOn && moment().isBefore(moment(snapshot.notifications.company.initial.sendOn));
-        var isOverdue = latestReminder.sendOn && moment().subtract(14, 'd').isAfter(moment(latestReminder.sendOn));
+      else if(snapshot.notifications.company.initial.sendOn) {
 
+        var isScheduled = moment().isBefore(moment(snapshot.notifications.company.initial.sendOn));
+        var isOverdue = moment().subtract(30, 'd').isAfter(moment(snapshot.notifications.company.reminder.sendOn || snapshot.notifications.company.initial.sendOn));
+        
         if(isScheduled) {
           snapshot.status = 'Scheduled';
           snapshot.action = null;
@@ -531,10 +486,9 @@ module.exports = function(mongoose, config) {
 
         else {
           snapshot.status = 'In Progress';
-          if(isManagedServices && isSubmitted && !isRejected) snapshot.action = 'Review';
-          else if(isManagedServices && isSubmitted && isRejected) snapshot.action = 'Rejected';
-          else if(latestReminder.sentOn) snapshot.action = latestReminder.status;
-          else snapshot.action = snapshot.notifications.company.initial.status;
+          if(snapshot.managedServices && snapshot.submittedOn) snapshot.action = 'Review';
+          else if(snapshot.notifications.company.reminder.status) snapshot.action = snapshot.notifications.company.reminder.status;
+          else if (snapshot.notifications.company.initial.status) snapshot.action = snapshot.notifications.company.initial.status;
         }
 
       }
@@ -550,22 +504,11 @@ module.exports = function(mongoose, config) {
 
   });
 
-  Financials.post('init', function(doc, next) {
-
-    return next();
-
-  });
-
-  Financials.post('remove', function(doc) {
-    // todo
-  });
-
   ///////////////////////////////////////////////////////////////////////////////////////
   // CONFIG
   ///////////////////////////////////////////////////////////////////////////////////////
 
   Financials.set('toJSON', { virtuals: true });
-  Financials.set('usePushEach', true);
   Financials.set('autoIndex', false);
 
   Financials.on('index', function(err) { console.log('error building financials indexes: ' + err); });

package/lib/Flag.js

@@ -23,6 +23,14 @@ module.exports = function(mongoose, config) {
 
   Flag.statics.createForModel = function(flag, Model, modelId, cb) {
 
+    if (!cb) { throw new Error('cb is required'); }
+    if (!flag) { throw new Error('flag is required'); }
+    if (!Model) { throw new Error('Model is required'); }
+    if (!modelId) { throw new Error('modelId is required'); }
+    if (!mongoose.Types.ObjectId.isValid(modelId)) { return cb(new Error('modelId is not a valid ObjectId'), null); }
+
+    const self = this;
+
     var addToModel = function(err, createdFlag) {
       if (err) return cb(err, null);
       Model.findByIdAndUpdate(modelId, { $push: { flags: createdFlag }}, { new: true, upsert: false }, function(err, addedTo) {
@@ -34,24 +42,31 @@ module.exports = function(mongoose, config) {
     };
 
     flag.createdOn = new Date();
-    flag.customer = config.CUSTOMER_ID;
 
-    this.create(flag, addToModel);
+    self.create(flag, addToModel);
 
   };
 
-  Flag.statics.delete = function(flagId, cb) {
+  Flag.statics.delete = function(flagId, customerId, cb) {
 
-    var self = this;
+    if (!cb) { throw new Error('cb is required'); }
+    if (!flagId) { throw new Error('flagId is required'); }
+    if (!mongoose.Types.ObjectId.isValid(flagId)) { return cb(new Error('flagId 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 self = this;
 
     // Not strictly necessary but provides verification that the flag being deleted belongs to the customer doing the deleting
-    self.findOne({
+    let query = self.findOne({
       '_id': flagId,
-      'customer': config.CUSTOMER_ID
-    }, function(err, flag) {
+      'customer': customerId
+    });
 
-      if (err) return cb(err, null);
-      else if (!flag) return cb(null, null);
+    query.exec(function(err, flag) {
+
+      if (err) { return cb(err, null); }
+      else if (!flag) { return cb(null, null); }
 
       flag.remove(cb);
 
@@ -60,10 +75,19 @@ module.exports = function(mongoose, config) {
   };
 
   Flag.statics.getById = function(id, cb) {
-    this.findOne({
-      '_id': id,
-      'customer': config.CUSTOMER_ID
-    }).exec(cb);
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!id) { throw new Error('id is required'); }
+    if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
+
+    const self = this;
+
+    let query = self.findById({
+      '_id': id
+    });
+
+    query.exec(cb);
+
   };
 
   Flag.statics.modifyById = function(id, update, cb) {
@@ -95,7 +119,6 @@ module.exports = function(mongoose, config) {
   });
 
   Flag.set('autoIndex', false);
-  Flag.set('usePushEach', true);
   Flag.on('index', function(err) { console.log('error building Flag indexes: ' + err); });
 
   mongoose.model('Flag', Flag);

package/lib/Fund.js

@@ -5,23 +5,19 @@ module.exports = function(mongoose, config) {
   var Schema = mongoose.Schema;
   var Round = mongoose.model('Round');
   var _ = require('underscore');
-  var env = process.env.NODE_ENV || 'development';
 
   var Fund = new Schema({
+
     name: { type: String, required: true, unique: true },
     slug: { type: String, required: true, unique: true },
     shortName: { type: String, required: true },
-    abbreviation: { type: String },
+    abbreviation: { type: String, required: true },
     spv: { type: Boolean, default: false },
     hexColorCode: { type: String, required: true, default: '#cccccc' },
     closeDate: { type: Date },
     amount: { type: Number },
-    crunchbase: { uuid: { type: String, default: '', unique: true } },
-    transactions: [{
-      type: { type: String, enum: ['fees', 'expenses', 'carry'] },
-      amount: { type: Number, default: 0 },
-      date: { type: Date, default: null },
-    }],
+    crunchbase: { uuid: { type: String, default: '', unique: true } }
+
   });
 
   /************* BASIC FIELDS **********************/
@@ -152,7 +148,8 @@ module.exports = function(mongoose, config) {
     if (!query) return cb(null, []);
 
     var conditions = {
-      'name': new RegExp(query, "i")
+      'name': new RegExp(query.query, "i"),
+      'deleted': {$ne: true}
     };
 
     this
@@ -171,31 +168,7 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Fund.statics.removeTransactions = function removeTransactions(cb) {
-
-    var self = this;
-
-    var query = self.update(
-      { $set: { transactions: [] } },
-      { multi : true }
-    );
-    query.exec(cb);
-
-  };
-
-  Fund.post('remove', function(doc) {
-    // Debt.debts.internal.fund
-    // Document.fundInvolved
-    // Investment.internal.fund
-    // Investor.funds
-    // LimitedPartner.fundsInvested.fund
-    // Message.fundsInvolved
-    // News.fundsInvolved
-    // PortfolioCompany.fundsInvested
-  });
-
   Fund.set('autoIndex', false);
-  Fund.set('usePushEach', true);
   Fund.on('index', function(err) { console.log('error building fund indexes: ' + err); });
 
   mongoose.model('Fund', Fund);