@dhyasama/totem-models 1.0.0

package/lib/List.js

@@ -0,0 +1,217 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    env = process.env.NODE_ENV || 'development',
+    utils = require('@dhyasama/ffvc-utilities'),
+    _ = require('underscore'),
+    postFind = require('mongoose-post-find');
+
+  var List = new Schema({
+
+    customer: { type: Schema.ObjectId, ref: 'Organization', index: true, required: true },
+
+    name: { type: String, index: true, required: true },
+
+    key: { type: String, required: true, unique: true },
+
+    createdOn: { type: Date, index: false, required: true },
+
+    createdBy: { type: Schema.ObjectId, ref: 'Person', index: false, required: true },
+
+    // Keeping these separate to facilitate population
+
+    // todo - how to update these with company consolidation?
+
+    limitedPartners: [{ type: Schema.ObjectId, ref: 'LimitedPartner', index: false, required: false }],
+
+    organizations: [{ type: Schema.ObjectId, ref: 'Organization', index: false, required: false }],
+
+    people: [{ type: Schema.ObjectId, ref: 'Person', index: false, required: false }]
+  });
+
+  // Items are kept separate to facilitate population
+  // This is a convenience function to get the full list of items
+  List.virtual('items').get(function () {
+
+    var self = this;
+    var allItems = [];
+
+    var addItems = function(type, items) {
+      _.each(self[type], function(item) {
+        items.push({
+          type: type,
+          item: item
+        });
+      });
+    };
+
+    addItems('limitedPartners', allItems);
+    addItems('organizations', allItems);
+    addItems('people', allItems);
+
+    allItems = _.sortBy(allItems, function(item) {
+      if (!item.item || !item.item.name) return null;
+      else return item.type == 'people' ? item.item.name.first + ' ' + item.item.name.last : item.item.name;
+    });
+
+    allItems = _.compact(allItems);
+
+    return allItems;
+
+  });
+
+  List.statics.addItem = function(listId, itemId, collection, cb) {
+
+    var self = this;
+
+    self.findOne({
+      '_id': listId,
+      'customer': config.CUSTOMER_ID
+    }, function(err, result) {
+
+      if (err) return cb(err, null);
+      if (!result) return cb(null, null);
+
+      result[collection].push(itemId);
+
+      result.save(cb);
+
+    });
+
+  };
+
+  List.statics.createList = function(name, items, creator, cb) {
+
+    var self = this;
+    var CUSTOMER_ID = config.CUSTOMER_ID;
+
+    if (CUSTOMER_ID == 'GLOBAL_PROCESS') throw new Error('Cannot create lists in a global process');
+    if (!name) throw new Error('Name is required');
+    if (!items) items = {};
+    if (!cb) throw new Error('cb is required');
+
+    var list = new self();
+    list.customer = config.CUSTOMER_ID;
+    list.name = name;
+    list.createdOn = new Date();
+    list.createdBy = creator;
+    list.limitedPartners = items.limitedPartners || [];
+    list.organizations = items.organizations || [];
+    list.people = items.people || [];
+
+    // enforce unique customer/name tuple
+    list.key = list.customer + '-' + list.name.split(' ').join('-');
+
+    list.save(cb);
+
+  };
+
+  List.statics.getById = function (id, cb) {
+    this
+      .findOne({
+        '_id': id,
+        'customer': config.CUSTOMER_ID
+      })
+      .populate('createdBy', 'name avatarUrl')
+      .populate('limitedPartners', 'name logoUrl')
+      .populate('organizations', 'name logoUrl')
+      .populate('people', 'name title avatarUrl')
+      .exec(cb);
+  };
+
+  List.statics.getLists = function(cb) {
+
+    var self = this;
+
+    self
+      .find({ 'customer': config.CUSTOMER_ID })
+      .populate('limitedPartners', 'name logoUrl')
+      .populate('organizations', 'name logoUrl')
+      .populate('people', 'name title avatarUrl')
+      .exec(cb);
+
+  };
+
+  List.statics.remove = function(id, cb) {
+    this.findOneAndRemove({
+      '_id': id,
+      'customer': config.CUSTOMER_ID
+    }, cb);
+  };
+
+  List.statics.removeItem = function(listId, itemId, collection, cb) {
+
+    var self = this;
+
+    var update = {};
+    update[collection] = itemId;
+
+    self.findOneAndUpdate({
+      '_id': listId,
+      'customer': config.CUSTOMER_ID
+    }, { $pull: update }, { new: true }, cb);
+
+  };
+
+  List.pre('save', function(next) {
+
+    var self = this;
+
+    var dedupeArray = function dedupeArray(arr) {
+      return _.uniq(arr, function(item) {
+        return (utils.isValidObjectId(item) ? item : item._id).toString();
+      });
+    };
+
+    // enforce unique items in arrays
+    self.limitedPartners = dedupeArray(self.limitedPartners);
+    self.organizations = dedupeArray(self.organizations);
+    self.people = dedupeArray(self.people);
+
+    next();
+
+  });
+
+  List.set('autoIndex', (env == 'development'));
+  List.set('toJSON', { virtuals: true });
+
+  List.plugin(postFind, {
+
+    find: function(results, done) {
+
+      var CUSTOMER_ID = config.CUSTOMER_ID;
+
+      if (CUSTOMER_ID == 'GLOBAL_PROCESS') return done(null, results);
+
+      // Reject any item that is for a different customer
+      results = _.reject(results, function(item) {
+        return item.customer.toString() != CUSTOMER_ID;
+      });
+
+      return done(null, results);
+
+    },
+
+    findOne: function(result, done) {
+
+      var CUSTOMER_ID = config.CUSTOMER_ID;
+
+      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);
+
+    }
+
+  });
+
+  List.set('autoIndex', true);
+  List.on('index', function(err) { console.log('error building list indexes: ' + err); });
+
+  mongoose.model('List', List);
+
+};

package/lib/News.js

@@ -0,0 +1,161 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    env = process.env.NODE_ENV || 'development',
+    _ = require('underscore'),
+
+    News = new Schema({
+
+      title: { type: String, required: true },
+
+      createdOn: { type: Date, required: true },
+
+      createdBy: { type: String, required: true },
+
+      excerpt: { type: String, required: false, default: null },
+
+      link: { type: String, required: true },
+
+      publication: { type: String },
+
+      fundsInvolved: [{
+        type: Schema.ObjectId,
+        ref: 'Fund'
+      }],
+
+      // TODO - make all news about port cos
+      // required: true
+      // remove internal
+      // update admin to reflect these changes
+
+      // todo - put new org id in org field
+      portfolioCompany: {
+        type: Schema.ObjectId,
+        ref: 'PortfolioCompany',
+        required: false,
+        default: null
+      },
+
+      org: {
+        type: Schema.ObjectId,
+        ref: 'Organization',
+        required: false,
+        default: null
+      },
+
+      internal: { type: Boolean, default: false },
+
+      // TODO - this will be going away
+      discourse: {
+        id: { type: String },
+        firstPostId: { type: String },
+        slug: { type: String }
+      },
+
+      extracted: { type: Schema.Types.Mixed }
+
+    });
+
+  News.statics.getById = function (id, cb) {
+
+    this
+      .findById(id)
+      .populate('org fundsInvolved')
+      .exec(cb);
+
+  };
+
+  News.statics.list = function (cb) {
+
+    this
+      .find()
+      .populate('org fundsInvolved')
+      .sort('-createdOn')
+      .exec(cb);
+
+  };
+
+  News.statics.listForCompany = function (id, cb) {
+
+    this
+      .find({ org: id })
+      .populate('org fundsInvolved')
+      .sort('-createdOn')
+      .exec(cb);
+
+  };
+
+  News.statics.listForCompanyBySlug = function (slug, cb) {
+
+    this
+      .find()
+      .populate('org fundsInvolved')
+      .sort('-createdOn')
+      .exec(function (err, news) {
+
+        if (err) { return cb(err, null); }
+
+        var filtered = _.filter(news, function(item) {
+          return item.org && item.org.slug == slug;
+        });
+
+        return cb(null, filtered);
+
+      });
+
+  };
+
+  News.statics.listInternal = function (cb) {
+
+    this
+      .find({ internal: true })
+      .populate('org fundsInvolved')
+      .sort('-createdOn')
+      .exec(cb);
+
+  };
+
+  News.statics.listForFunds = function (fundIds, cb) {
+
+    if (!fundIds || fundIds.length == 0) return cb(null, null);
+
+    this
+      .find({ fundsInvolved: { $in : fundIds } })
+      .populate('org fundsInvolved')
+      .sort('-createdOn')
+      .exec(function(err, result) {
+
+        if (err) return cb(err, null);
+
+        _.each(result, function(newsItem) {
+          newsItem.fundsInvolved = _.filter(newsItem.fundsInvolved, function(fund) { return fundIds.indexOf(fund._id.toString()) >= 0; });
+        });
+
+        return cb(null, result);
+
+      });
+
+  };
+
+  News.statics.upsert = function (news, cb) {
+    news.markModified('extracted');
+    news.save(cb);
+  };
+
+  News.statics.delete = function(id, cb) {
+    this.getById(id, function(err, item) {
+      if (err) return cb(err, null);
+      item.remove(cb);
+    });
+  };
+
+  News.set('autoIndex', true);
+  News.on('index', function(err) { console.log('error building news indexes: ' + err); });
+
+  mongoose.model('News', News);
+
+};

package/lib/Note.js

@@ -0,0 +1,170 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    env = process.env.NODE_ENV || 'development',
+    async = require('async'),
+    _ = require('underscore'),
+    postFind = require('mongoose-post-find'),
+    querystring = require('querystring');
+
+  var Note = new Schema({
+
+    customer: { type: Schema.ObjectId, ref: 'Organization', index: true, required: true },
+
+    createdOn: { type: Date, index: false, required: true },
+
+    createdBy: { type: Schema.ObjectId, ref: 'Person', index: false, required: true },
+
+    text: { type: String, index: false, required: true, trim: true }
+
+  });
+
+  Note.statics.createForCalendarEvent = function(providerEventId, creatorPersonId, text, cb) {
+
+    var self = this;
+    var Person = mongoose.model('Person');
+
+    var queue = async.queue(function(task, callback) {
+      Person.update(
+        { '_id': task.personId, 'calendarEventSummaries.providerEventId': providerEventId },
+        { "$push": { "calendarEventSummaries.$.notes": task.note } },
+        callback);
+    }, 8);
+
+    // get all people with cal event summary with providerEventId
+    Person
+      .find({ 'calendarEventSummaries.providerEventId': providerEventId })
+      .exec(function(err, externalAttendees) {
+
+        if (err) return cb(err, null);
+
+        var note = {
+          createdBy: creatorPersonId,
+          text: text,
+          createdOn: new Date(),
+          customer: config.CUSTOMER_ID
+        };
+
+        // create the note once
+        self.create(note, function(err, result) {
+
+          if (err) return cb(err, null);
+
+          queue.drain = function() { return cb(null, result); };
+
+          // add it to each person that attended the event
+          _.each(externalAttendees, function(person) {
+
+            // find the event summary
+            var eventSummary = _.find(person.calendarEventSummaries, function(ces) {
+              return ces.providerEventId == providerEventId;
+            });
+
+            // attach note reference to event summary
+            if (eventSummary) {
+              queue.push({
+                personId: person._id,
+                note: result
+              }, function(err, result) {
+                if (err) console.log('ERR:', err);
+              });
+            }
+
+          });
+
+        });
+
+      });
+
+  };
+
+  Note.statics.createForModel = function(note, Model, modelId, cb) {
+
+    var addToModel = function(err, createdNote) {
+      if (err) return cb(err, null);
+      Model.findByIdAndUpdate(modelId, { $push: { notes: createdNote }}, { new: true, upsert: false }, function(err, addedTo) {
+        return cb(err, {
+          note: createdNote,
+          addedTo: addedTo
+        });
+      });
+    };
+
+    note.createdOn = new Date();
+    note.customer = config.CUSTOMER_ID;
+
+    this.create(note, addToModel);
+
+  };
+
+  Note.statics.getById = function(id, cb) {
+    this.findOne({
+      '_id': id,
+      'customer': config.CUSTOMER_ID
+    }).exec(cb);
+  };
+
+  Note.statics.delete = function(noteId, cb) {
+
+    var self = this;
+
+    // Not strictly necessary but provides verification that the note being deleted belongs to the customer doing the deleting
+    self.findOne({
+      '_id': noteId,
+      'customer': config.CUSTOMER_ID
+    }, function(err, note) {
+
+      if (err) return cb(err, null);
+      else if (!note) return cb(null, null);
+
+      note.remove(cb);
+
+    });
+
+  };
+
+  Note.post('init', function() {
+    var self = this;
+    self.text = querystring.unescape(self.text);
+  });
+
+  Note.plugin(postFind, {
+
+    find: function(results, done) {
+
+      var CUSTOMER_ID = config.CUSTOMER_ID;
+
+      if (CUSTOMER_ID == 'GLOBAL_PROCESS') return done(null, results);
+
+      // Reject any item that is for a different customer
+      results = _.reject(results, function(item) {
+        return item.customer.toString() != CUSTOMER_ID;
+      });
+
+      return done(null, results);
+
+    },
+
+    findOne: function(result, done) {
+
+      var CUSTOMER_ID = config.CUSTOMER_ID;
+
+      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);
+
+    }
+
+  });
+
+  Note.set('autoIndex', true);
+  Note.on('index', function(err) { console.log('error building note indexes: ' + err); });
+
+  mongoose.model('Note', Note);
+
+};