@dhyasama/totem-models 1.0.0

package/lib/Document.js

@@ -0,0 +1,357 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    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}),
+    _ = require('underscore');
+
+  var Document = new Schema({
+
+    lpid: { type: Schema.Types.ObjectId, 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 },
+
+    s3key: { type: String, required: true },
+
+    doctype: {
+      type: String,
+      required: true,
+      enum: ['annual-audit', 'portfolio-holding', 'capital-call', 'k1', 'distribution', 'quarterly-account-statement'] },
+
+    scope: {
+      type: String,
+      required: true,
+      enum: ['lp', 'fund'] },
+
+    // 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 }
+    },
+
+    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'] }
+    }]
+
+  });
+
+
+
+  /////////////////////
+  // 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;
+
+  };
+
+  Document.methods.friendlyFilesize = function() {
+    return utils.humanizeFilesize(this.filesize);
+  };
+
+  Document.methods.encryptId = function() {
+    return crypto.encrypt(this.id);
+  };
+
+
+
+  ////////////////////////
+  // 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);
+      });
+
+  };
+
+  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.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;
+        });
+        encryptDocumentIds(docs);
+        cb(err, docs);
+      });
+
+  };
+
+  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);
+      });
+
+  };
+
+  Document.statics.upsert = function(doc, cb) {
+    return save(doc, cb);
+  };
+
+
+
+  ////////////////////////
+  // HELPERS
+  ////////////////////////
+
+  function encryptDocumentIds(documents) {
+
+    var result = _.map(documents, function(doc) {
+      doc.secureid = crypto.encrypt(doc.id);
+      return doc;
+    });
+
+    return result;
+
+  }
+
+  function listAnnualAudits(model, fundId, year, cb) {
+
+    model
+      .find({ doctype: 'annual-audit', fundInvolved: fundId, year: year })
+      .sort({ year: -1 })
+      .exec(function (err, documents) {
+        encryptDocumentIds(documents);
+        cb(err, documents);
+      });
+
+  };
+
+  function listCapitalCalls(model, fundId, callNumber, cb) {
+
+    model
+      .find({ doctype: 'capital-call', fundInvolved: fundId, 'capitalCall.noticeNumber': callNumber })
+      .sort({ 'capitalCall.noticeNumber': -1 })
+      .exec(function (err, documents) {
+        encryptDocumentIds(documents);
+        cb(err, documents);
+      });
+
+  };
+
+  function listK1s(model, fundId, year, cb) {
+
+    model
+      .find({ doctype: 'k1', fundInvolved: fundId, year: year })
+      .sort({ 'year': -1 })
+      .exec(function (err, documents) {
+        encryptDocumentIds(documents);
+        cb(err, documents);
+      });
+
+  };
+
+  function listPortfolioHoldings(model, fundId, year, quarter, cb) {
+
+    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));
+      });
+
+  };
+
+  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);
+    });
+  }
+
+  Document.set('autoIndex', (env == 'development'));
+  Document.on('index', function(err) { console.log('error building document indexes: ' + err); });
+
+  mongoose.model('Document', Document);
+
+};

package/lib/Fund.js

@@ -0,0 +1,143 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var Schema = mongoose.Schema
+  var env = process.env.NODE_ENV || 'development';
+
+  var Fund = new Schema({
+
+    name: { type: String, required: true },
+    slug: { type: String, required: true, unique: true },
+    shortName: { 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 } }
+
+  });
+
+  /************* BASIC FIELDS **********************/
+
+  Fund.methods.newBasic = function(field, value) {
+
+    var compoundField = false;
+    if(field.split(".").length > 1) {
+      compoundField = true;
+    }
+
+    if(!compoundField) {
+      this[field] = value;
+    } else {
+      var parentField = field.split('.')[0];
+      var childField = field.split('.')[1];
+
+      this[parentField][childField] = value;
+    }
+
+  };
+
+  Fund.methods.updateBasic = function(field, value) {
+
+    var compoundField = false;
+    if(field.split(".").length > 1) {
+      compoundField = true;
+    }
+
+    if(!compoundField) {
+      var currentVal = this[field];
+      this[field] = value;
+    } else {
+      var parentField = field.split('.')[0];
+      var childField = field.split('.')[1];
+
+      var currentVal = this[parentField][childField];
+      this[parentField][childField] = value;
+    }
+
+    var oldFieldObj = {
+      field: field,
+      value: currentVal,
+      end: new Date()
+    };
+
+    this.previous.push(oldFieldObj);
+
+  };
+
+  ///////////////////////////////////////
+
+  Fund.statics.getById = function (id, cb) {
+    this
+      .findById(id)
+      .exec(cb);
+  };
+
+  Fund.statics.getBySlug = function (slug, cb) {
+    this
+      .find({slug: slug})
+      .exec(cb);
+  };
+
+  Fund.statics.findBySlugs = function (slugs, cb) {
+    this
+      .find({ 'slug': { $in : slugs }})
+      .exec(cb);
+  };
+
+  Fund.statics.getCount = function (cb) {
+    this
+      .count({})
+      .exec(cb);
+  };
+
+  Fund.statics.list = function (cb) {
+    this
+      .find()
+      .exec(cb);
+  };
+
+  Fund.statics.search = function (query, options, cb) {
+
+    if (!cb) throw new Error('cb is required');
+    if (!query) return cb(null, []);
+
+    var conditions = {
+      'name': new RegExp(query.query, "i"),
+      'deleted': {$ne: true}
+    };
+
+    this
+      .find(conditions)
+      .sort('name')
+      .exec(cb);
+
+  };
+
+  Fund.statics.upsert = function(fund, username, cb) {
+
+    if (!fund) { return cb(new Error('Fund is required'), null); }
+    if (!username) { return cb(new Error('Username is required'), null); }
+
+    fund.save(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', true);
+  Fund.on('index', function(err) { console.log('error building fund indexes: ' + err); });
+
+  mongoose.model('Fund', Fund);
+
+};