@dhyasama/totem-models 3.1.0 → 3.2.1

package/.npmignore

@@ -0,0 +1,14 @@
+lib-cov
+*.seed
+*.log
+*.csv
+*.dat
+*.out
+*.pid
+*.gz
+
+npm-debug.log
+node_modules
+
+.DS_Store
+.idea

package/index.js

@@ -53,10 +53,12 @@ var bootstrap = function(mongoose, config) {
   require('./lib/Activity.js')(mongoose, config);
   require('./lib/CalendarEvent.js')(mongoose, config);
   require('./lib/CapTable.js')(mongoose, config);
+  require('./lib/Document.js')(mongoose, config);
   require('./lib/Financials.js')(mongoose, config);
   require('./lib/Interaction.js')(mongoose, config);
   require('./lib/Investment.js')(mongoose, config);
   require('./lib/List.js')(mongoose, config);
+  require('./lib/Message.js')(mongoose, config);
   require('./lib/News.js')(mongoose, config);
   require('./lib/Webhook.js')(mongoose, config);
 

package/lib/Document.js

@@ -8,346 +8,128 @@ module.exports = function(mongoose, config) {
     env = process.env.NODE_ENV || 'development',
     s3 = require('@dhyasama/ffvc-s3'),
     utils = require('@dhyasama/ffvc-utilities'),
-    Crypto = require('@dhyasama/ffvc-crypto'),
-    crypto = new Crypto({'key': config.crypto.key}),
+    postFind = require('mongoose-post-find'),
     _ = require('underscore');
 
   var Document = new Schema({
 
-    lpid: { type: Schema.Types.ObjectId, required: true },
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
 
-    fundInvolved: {
-      type: Schema.ObjectId,
-      ref: 'Fund'
-    },
-
-    published: { type: Boolean, required: true },
-
-    filename: { type: String, required: true },
-
-    filetype: { type: String, required: true },
-
-    filesize: { type: String, required: true },
+    createdOn: { type: Date, required: true },
 
-    s3key: { type: String, required: true },
+    createdBy: { type: Schema.ObjectId, ref: 'Person', index: false, required: true },
 
-    doctype: {
-      type: String,
-      required: true,
-      enum: ['annual-audit', 'portfolio-holding', 'capital-call', 'k1', 'distribution', 'quarterly-account-statement'] },
+    name: { type: String, required: true },
 
-    scope: {
-      type: String,
-      required: true,
-      enum: ['lp', 'fund'] },
+    contentType: { type: String, required: true },
 
-    // for fund-level docs:
-    //  upload one doc to s3 with this id in the key
-    //  e.g., an annual audit for ff Rose would be stored at documents/[scopeid] and shared by all lps in ff Rose
-    // for lp-level docs:
-    //   used to get a batch of docs that were uploaded together
-    //   e.g., a capital call for ff Sapphire requires a separate document to be uploaded for each lp in the fund
-    //   scopeid allows retrieving all of the doc records at once for admin purposes
-    //   unlike fund level docs, these are stored at documents/[_id] so they can be retrieved on an individual basis
-    scopeid: { type: String, required: true },
-
-    year: { type: Number, required: false },
-
-    quarter: {
-      type: String,
-      required: false,
-      enum: [null, '', 'Q1', 'Q2', 'Q3', 'Q4'] },
-
-    capitalCall: {
-      noticeNumber: { type: Number, required: false },
-      noticeDate: { type: Date, required: false },
-      dueDate: { type: Date, required: false }
-    },
+    contentLength: { type: String, required: true },
 
-    description: { type: String, required: false },
-
-    history: [{
-      timestamp: { type: Date, required: true },
-      username: { type: String, required: true },
-      action: { type: String, required: true, enum: ['created', 'published', 'unpublished', 'replaced'] }
-    }]
+    s3: {
+      bucket: { type: String, required: true, trim: true },
+      key: { type: String, required: true, trim: true }
+    }
 
   });
 
 
 
-  /////////////////////
-  // INSTANCE METHODS
-  /////////////////////
-
-  Document.methods.friendlyFundName = function() {
-    var fund = this.fundInvolved.name;
-    return fund;
-  };
-
-  Document.methods.friendlyDocType = function() {
-    var doctype = this.doctype ? utils.capitalizeFirstLetters(this.doctype.toLowerCase().split('-').join(' ')) : '';
-    return doctype;
-  };
-
-  Document.methods.friendlyDocumentName = function() {
-    var year = this.year ? this.year + ' ' : '';
-    var quarter = this.quarter ? this.quarter + ' ' : '';
-    var callNum = this.doctype == 'capital-call' && utils.isNumeric(this.capitalCall.noticeNumber) ? ' #' + this.capitalCall.noticeNumber : '';
-    var desc = this.doctype == 'distribution' ? ' - ' + this.description : '';
-
-    return year + quarter + this.friendlyDocType() + callNum + desc;
-
-  };
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // METHODS
+  // Methods operate on a single document that has already been returned
+  // Note that running a method on a document does not save it
+  ///////////////////////////////////////////////////////////////////////////////////////
 
   Document.methods.friendlyFilesize = function() {
-    return utils.humanizeFilesize(this.filesize);
-  };
-
-  Document.methods.encryptId = function() {
-    return crypto.encrypt(this.id);
+    return utils.humanizeFilesize(this.contentLength);
   };
 
 
 
-  ////////////////////////
+  //////////////////////////////////////////////////////
   // STATICS
-  ////////////////////////
-
-  Document.statics.exists = function(meta, cb) {
-
-    var model = this;
-
-    var done = function(err, docs) {
-      return cb(!err && docs.length >= 1, docs[0]);
-    };
-
-    switch(meta.doctype.toLowerCase()) {
-      case 'annual-audit':
-        listAnnualAudits(model, meta.fundId, meta.year, done);
-        break;
-      case 'capital-call':
-        listCapitalCalls(model, meta.fundId, meta.callNumber, done);
-        break;
-      case 'portfolio-holding':
-        listPortfolioHoldings(model, meta.fundId, meta.year, meta.quarter, done);
-        break;
-      case 'k1':
-        listK1s(model, meta.fundId, meta.year, done);
-        break;
-      case 'quarterly-account-statement':
-        listQuarterlyAccountStatements(model, meta.fundId, meta.year, meta.quarter, done);
-        break;
-      default:
-        return cb(false, null);
-        break;
-    }
-
-  };
-
-  Document.statics.getById = function (cipher, cb) {
-
-    var id = crypto.decrypt(cipher);
-
-    this
-      .findById(id)
-      .populate({
-        path: 'lpid',
-        model: 'LimitedPartner',
-        select: 'name shortName id'
-      })
-      .populate('fundInvolved')
-      .exec(function (err, document) {
-        if (document) { document.secureid = cipher; }
-        document.secureid = cipher;
-        cb(err, document);
-      });
-
-  };
+  // Statics operate on the entire collection
+  //////////////////////////////////////////////////////
 
-  Document.statics.list = function (cb) {
-
-    this
-      .find()
-      .populate({
-        path: 'lpid',
-        model: 'LimitedPartner',
-        select: 'name shortName id'
-      })
-      .populate('fundInvolved')
-      .sort({ year: -1, quarter: -1 })
-      .exec(function (err, documents) {
-        encryptDocumentIds(documents);
-        cb(err, documents);
-      });
-
-  };
+  Document.statics.createForModel = function(doc, Model, modelId, cb) {
 
-  Document.statics.listAllForLP = function (lpid, cb) {
-
-    this
-      .find({ lpid: lpid, published: true })
-      .populate('fundInvolved')
-      .sort({ year: -1, quarter: -1, fund: 1 })
-      .exec(function (err, documents) {
-        encryptDocumentIds(documents);
-        return cb(err, documents);
-      });
-
-  };
-
-  Document.statics.listForScopeId = function (cipher, cb) {
-
-    // lp-level docs are grouped to scope id to faciliate pulling a batch all at once
-
-    var id = crypto.decrypt(cipher);
-
-    this
-      .find({ 'scopeid': id })
-      .populate({
-        path: 'lpid',
-        model: 'LimitedPartner',
-        select: 'name shortName id'
-      })
-      .populate('fundInvolved')
-      .exec(function (err, documents) {
-        console.log(documents.length);
-        encryptDocumentIds(documents);
-        return cb(err, _.sortBy(documents, function(doc) {
-          var lowered = doc.lpid && doc.lpid.name ? doc.lpid.name.toLowerCase() : 'Unknown';
-          return lowered;
-        }));
-      });
-
-  };
-
-  Document.statics.listFundLevel = function (cb) {
-
-    this
-      .find({ 'scope': 'fund' })
-      .populate({
-        path: 'lpid',
-        model: 'LimitedPartner',
-        select: 'name shortName id'
-      })
-      .populate('fundInvolved')
-      .sort({ year: -1, quarter: -1 })
-      .exec(function (err, documents) {
-        var docs = _.uniq(documents, false, function(doc) {
-          return doc.scopeid;
+    var addToModel = function(err, createdDoc) {
+      if (err) return cb(err, null);
+      Model.findByIdAndUpdate(modelId, { $push: { documents: createdDoc }}, { new: true, upsert: false }, function(err, addedTo) {
+        return cb(err, {
+          document: createdDoc,
+          addedTo: addedTo
         });
-        encryptDocumentIds(docs);
-        cb(err, docs);
       });
+    };
 
-  };
+    doc.createdOn = new Date();
 
-  Document.statics.listLpLevel = function (cb) {
-
-    this
-      .find({ 'scope': 'lp' })
-      .populate({
-        path: 'lpid',
-        model: 'LimitedPartner',
-        select: 'name shortName id'
-      })
-      .populate('fundInvolved')
-      .sort({ year: -1 })
-      .exec(function (err, documents) {
-        var docs = _.uniq(documents, false, function(doc) {
-          return doc.scopeid;
-        });
-        encryptDocumentIds(docs);
-        cb(err, docs);
-      });
+    this.create(doc, addToModel);
 
   };
 
-  Document.statics.upsert = function(doc, cb) {
-    return save(doc, cb);
-  };
+  Document.statics.delete = function(id, cb) {
 
+    var self = this;
 
+    // Not strictly necessary but provides verification that the document being deleted belongs to the customer doing the deleting
+    self.findOne({
+      '_id': id,
+      'customer': config.CUSTOMER_ID
+    }, function(err, doc) {
 
-  ////////////////////////
-  // HELPERS
-  ////////////////////////
+      if (err) return cb(err, null);
+      else if (!doc) return cb(null, null);
 
-  function encryptDocumentIds(documents) {
+      doc.remove(cb);
 
-    var result = _.map(documents, function(doc) {
-      doc.secureid = crypto.encrypt(doc.id);
-      return doc;
     });
 
-    return result;
+  };
 
-  }
+  Document.statics.getById = function (id, cb) {
+    this.findOne({
+      '_id': id,
+      'customer': config.CUSTOMER_ID
+    }).exec(cb);
+  };
 
-  function listAnnualAudits(model, fundId, year, cb) {
+  Document.plugin(postFind, {
 
-    model
-      .find({ doctype: 'annual-audit', fundInvolved: fundId, year: year })
-      .sort({ year: -1 })
-      .exec(function (err, documents) {
-        encryptDocumentIds(documents);
-        cb(err, documents);
-      });
+    find: function(results, done) {
 
-  };
+      var CUSTOMER_ID = config.CUSTOMER_ID;
 
-  function listCapitalCalls(model, fundId, callNumber, cb) {
+      if (CUSTOMER_ID == 'GLOBAL_PROCESS') return done(null, results);
 
-    model
-      .find({ doctype: 'capital-call', fundInvolved: fundId, 'capitalCall.noticeNumber': callNumber })
-      .sort({ 'capitalCall.noticeNumber': -1 })
-      .exec(function (err, documents) {
-        encryptDocumentIds(documents);
-        cb(err, documents);
+      // Reject any item that is for a different customer
+      results = _.reject(results, function(item) {
+        return item.customer.toString() != CUSTOMER_ID;
       });
 
-  };
-
-  function listK1s(model, fundId, year, cb) {
+      return done(null, results);
 
-    model
-      .find({ doctype: 'k1', fundInvolved: fundId, year: year })
-      .sort({ 'year': -1 })
-      .exec(function (err, documents) {
-        encryptDocumentIds(documents);
-        cb(err, documents);
-      });
+    },
 
-  };
+    findOne: function(result, done) {
 
-  function listPortfolioHoldings(model, fundId, year, quarter, cb) {
+      var CUSTOMER_ID = config.CUSTOMER_ID;
 
-    model
-      .find({ doctype: 'portfolio-holding', fundInvolved: fundId, year: year, quarter: quarter })
-      .sort({ year: -1, quarter: -1 })
-      .exec(function (err, documents) {
-        return cb(err, encryptDocumentIds(documents));
-      });
+      if (!result) return done(null, null);
+      else if (CUSTOMER_ID == 'GLOBAL_PROCESS') return done(null, result);
+      else if (result.customer.toString() == CUSTOMER_ID) return done(null, result);
+      else return done(null, null);
 
-  };
+    }
 
-  function listQuarterlyAccountStatements(model, fundId, year, quarter, cb) {
+  });
 
-    model
-      .find({ doctype: 'quarterly-account-statement', fundInvolved: fundId, year: year, quarter: quarter })
-      .sort({ year: -1, quarter: -1 })
-      .exec(function (err, documents) {
-        encryptDocumentIds(documents);
-        cb(err, documents);
-      });
 
-  };
 
-  function save(document, cb) {
-    document.save(function(err, updatedDocument) {
-      cb(err, updatedDocument);
-    });
-  }
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
 
   Document.set('autoIndex', false);
   Document.on('index', function(err) { console.log('error building document indexes: ' + err); });

package/lib/Interaction.js

@@ -23,7 +23,8 @@ module.exports = function(mongoose, config) {
       internal: [{ type: Schema.ObjectId, ref: 'Person', index: true }], // people from customer
       external: [{ type: Schema.ObjectId,  ref: 'Person', index: true }] // everyone else
     },
-    notes: [ { type: Schema.ObjectId, ref: 'Note' } ]
+    notes: [ { type: Schema.ObjectId, ref: 'Note' } ],
+    documents: [ { type: Schema.ObjectId, ref: 'Document' } ]
 
   });
 
@@ -77,7 +78,7 @@ module.exports = function(mongoose, config) {
 
     var self = this;
     var query = self.find({ totemCustomerId: customerId, _id: { $gt: sinceObjectId } });
-
+    query.populate('attendees.external');
     query.exec(cb);
 
   };

package/lib/LimitedPartner.js

@@ -625,6 +625,7 @@ module.exports = function(mongoose, config) {
     }
     else {
       query = self.find({ 'name': new RegExp(terms, "i"), 'fundsInvested.fund': { $in : self.customerFunds }}, self.getReadFilterKeys(role));
+
       getLps();
     }
 

package/lib/Message.js

@@ -0,0 +1,210 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    env = process.env.NODE_ENV || 'development',
+    _ = require('underscore'),
+    async = require('async'),
+    moment = require('moment'),
+    Document = mongoose.model('Document'),
+    Note = mongoose.model('Note');
+
+  var Message = new Schema({
+
+    createdOn: { type: Date, required: true },
+    webhook: { type: Schema.ObjectId, ref: 'Webhook', required: true },
+    type: { type: String, required: true, enum: ['email'], default: 'email' }, // for future options
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
+    subject: { type: String, required: false, default: null, trim: true },
+    body: { type: String, required: false, default: null, trim: true },
+    recipients: {
+      internal: [{ type: Schema.ObjectId, ref: 'Person', index: true }], // people from customer
+      external: [{ type: Schema.ObjectId,  ref: 'Person', index: true }] // everyone else
+    },
+    notes: [ { type: Schema.ObjectId, ref: 'Note' } ],
+    documents: [ { type: Schema.ObjectId, ref: 'Document' } ],
+    raw: { type: Schema.Types.Mixed, required: true }
+
+  });
+
+  ///////////////////////////////////////
+
+  Message.statics.addDocument = function(messageId, doc, cb) {
+
+    Document.createForModel(doc, this, messageId, cb);
+
+  };
+
+  Message.statics.addNote = function(messageId, creatorPersonId, text, cb) {
+
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, messageId, cb);
+
+  };
+
+  Message.statics.delete = function(messageId, customerId, cb) {
+
+    var self = this;
+
+    self.findOneAndRemove({
+      '_id': messageId,
+      'customer': customerId
+    }, cb);
+
+  };
+
+  Message.statics.deleteDocument = function(docId, cb) {
+
+    // Delete the doc itself along with any references
+
+    var self = this;
+
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'documents' : [docId] }
+      }, callback);
+    };
+
+    async.series([
+      Document.delete.bind(Document, docId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
+  Message.statics.deleteNote = function(noteId, cb) {
+
+    // Delete the note itself along with any references
+
+    var self = this;
+
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
+    };
+
+    async.series([
+      Note.delete.bind(Note, noteId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
+  Message.statics.getDocuments = function getDocuments(personIds, options, cb) {
+
+    var self = this;
+    var query = self.find({ customer: config.CUSTOMER_ID });
+
+    query.where({'attendees.external': { $in : personIds }});
+    query.populate({
+      path: 'documents',
+      match: { customer: config.CUSTOMER_ID }
+    });
+    query.deepPopulate([
+      'documents.createdBy'
+    ], {
+      populate: {
+        'documents.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
+    query.exec(cb);
+
+  };
+
+  Message.statics.getForCustomer = function getForCustomer(customerId, cb) {
+
+    var self = this;
+    var query = self.find({ customer: customerId });
+    query.exec(cb);
+
+  };
+
+  Message.statics.getForPeople = function getForPeople(personIds, options, cb) {
+
+    // This filters by customer so is NOT usable by admin tools
+    if (config.CUSTOMER_ID == 'GLOBAL_PROCESS') return cb(new Error('Access denied. Use getForPeopleLite.'), null);
+
+    var self = this;
+    var query = self.find({ customer: config.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: 'notes',
+      match: { customer: config.CUSTOMER_ID }
+    });
+    query.populate({
+      path: 'documents',
+      match: { customer: config.CUSTOMER_ID }
+    });
+    query.deepPopulate([
+      'notes.createdBy',
+      'documents.createdBy'
+    ], {
+      populate: {
+        'notes.createdBy': { select: 'name avatarUrl title' },
+        'documents.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
+    query.exec(cb);
+
+  };
+
+  Message.statics.getForPeopleLite = function getForPeopleLite(personIds, cb) {
+
+    // This doesn't filter by customer so is only usable by admin tools
+    if (config.CUSTOMER_ID != 'GLOBAL_PROCESS') return cb(new Error('Access denied'), null);
+
+    var self = this;
+    var query = self.find({'recipients.external': { $in : personIds }});
+    query.exec(cb);
+
+  };
+
+  Message.statics.getNotes = function getNotes(personIds, options, cb) {
+
+    var self = this;
+    var query = self.find({ customer: config.CUSTOMER_ID });
+
+    query.where({'attendees.external': { $in : personIds }});
+    query.populate({
+      path: 'notes',
+      match: { customer: config.CUSTOMER_ID }
+    });
+    query.deepPopulate([
+      'notes.createdBy'
+    ], {
+      populate: {
+        'notes.createdBy': { select: 'name avatarUrl title' }
+      }
+    });
+    query.exec(cb);
+
+  };
+
+  Message.statics.upsert = function(message, cb) {
+    message.createdOn = new Date();
+    message.save(cb);
+  };
+
+  ///////////////////////////////////////
+
+  Message.set('autoIndex', false);
+
+  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  Message.plugin(deepPopulate);
+
+  mongoose.model('Message', Message);
+
+};