@dhyasama/totem-models 1.19.1 → 1.20.0

package/index.js

@@ -19,6 +19,12 @@ var bootstrap = function(mongoose, config) {
 
   // todo - find a solution to load without worrying about order
 
+  // flag must be loaded before fund
+  // flag must be loaded before limited partner
+  // flag must be loaded before organization
+  // flag must be loaded before person
+  require('./lib/Flag.js')(mongoose, config);
+
   // note must be loaded before limited partner
   // note must be loaded before organization
   // note must be loaded before person

package/lib/Flag.js

@@ -0,0 +1,79 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    querystring = require('querystring');
+
+  var Flag = 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 },
+
+    status: { type: String, enum: ['open', 'closed'], default: 'open' }
+
+  });
+
+  Flag.statics.createForModel = function(flag, Model, modelId, cb) {
+
+    var addToModel = function(err, createdFlag) {
+      if (err) return cb(err, null);
+      Model.findByIdAndUpdate(modelId, { $push: { flags: createdFlag }}, { new: true, upsert: false }, function(err, addedTo) {
+        return cb(err, {
+          flag: createdFlag,
+          addedTo: addedTo
+        });
+      });
+    };
+
+    flag.createdOn = new Date();
+    flag.customer = config.CUSTOMER_ID;
+
+    this.create(flag, addToModel);
+
+  };
+
+  Flag.statics.delete = function(flagId, cb) {
+
+    var self = this;
+
+    // Not strictly necessary but provides verification that the flag being deleted belongs to the customer doing the deleting
+    self.findOne({
+      '_id': flagId,
+      'customer': config.CUSTOMER_ID
+    }, function(err, flag) {
+
+      if (err) return cb(err, null);
+      else if (!flag) return cb(null, null);
+
+      flag.remove(cb);
+
+    });
+
+  };
+
+  Flag.statics.getById = function(id, cb) {
+    this.findOne({
+      '_id': id,
+      'customer': config.CUSTOMER_ID
+    }).exec(cb);
+  };
+
+  Flag.post('init', function() {
+    var self = this;
+    self.text = querystring.unescape(self.text);
+  });
+
+  Flag.set('autoIndex', false);
+  Flag.on('index', function(err) { console.log('error building Flag indexes: ' + err); });
+
+  mongoose.model('Flag', Flag);
+
+};

package/lib/LimitedPartner.js

@@ -7,6 +7,7 @@ module.exports = function(mongoose, config) {
     CUSTOMER_ID = config.CUSTOMER_ID,
     LPS_ENABLED = config.LPS_ENABLED,
     Schema = mongoose.Schema,
+    Flag = mongoose.model('Flag'),
     Fund = mongoose.model('Fund'),
     Note = mongoose.model('Note'),
     Organization = mongoose.model('Organization'),
@@ -165,6 +166,8 @@ module.exports = function(mongoose, config) {
       resolved: { type: Boolean, default: false }
     },
 
+    flags: [ { type: Schema.ObjectId, ref: 'Flag' } ],
+
     notes: [ { type: Schema.ObjectId, ref: 'Note' } ]
 
   });
@@ -446,16 +449,19 @@ module.exports = function(mongoose, config) {
     var self = this;
     var query = self.findById(lpid)
 
-    query.select('notes')
+    query.select('notes people')
+    query.populate('people', 'name avatarUrl title calendarEventSummaries')
     query.populate({
       path: 'notes',
       match: { customer: config.CUSTOMER_ID }
     })
     query.deepPopulate([
-      'notes.createdBy'
+      'notes.createdBy',
+      'people.calendarEventSummaries.notes.createdBy'
     ], {
       populate: {
-        'notes.createdBy': { select: 'name avatarUrl title' }
+        'notes.createdBy': { select: 'name avatarUrl title' },
+        'people.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' }
       }
     })
     query.sort({'createdOn':-1})
@@ -638,6 +644,15 @@ module.exports = function(mongoose, config) {
 
   };
 
+  LimitedPartner.statics.addFlag = function(lpid, creatorPersonId, text, cb) {
+
+    Flag.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, lpid, cb);
+
+  };
+
   LimitedPartner.statics.addNote = function(lpid, creatorPersonId, text, cb) {
 
     Note.createForModel({
@@ -647,6 +662,27 @@ module.exports = function(mongoose, config) {
 
   };
 
+  LimitedPartner.statics.deleteFlag = function(flagId, cb) {
+
+    // Delete the flag itself along with any references
+
+    var self = this;
+
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'flags' : [flagId] }
+      }, callback);
+    };
+
+    async.series([
+      Flag.delete.bind(Flag, flagId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
   LimitedPartner.statics.deleteNote = function(noteId, cb) {
 
     // Delete the note itself along with any references
@@ -747,15 +783,15 @@ module.exports = function(mongoose, config) {
 
   LimitedPartner.plugin(filter, {
     readFilter: {
-      'admin': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
-      'lp-full': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
-      'lp-names': ['name', 'shortName', 'flagged'],
+      'admin': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-full': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-names': ['name', 'shortName', 'flagged', 'flags'],
       'none': []
     },
     writeFilter: {
-      'admin': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
-      'lp-full': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'notes'],
-      'lp-names': ['flagged'],
+      'admin': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-full': ['name', 'shortName', 'start', 'people', 'documentSlugs', 'fundsInvested', 'contact', 'distributions', 'k1', 'entered', 'status', 'flagged', 'flags', 'notes'],
+      'lp-names': ['flagged', 'flags'],
       'none': []
     },
     defaultFilterRole: 'none', // default to no read or write
@@ -765,7 +801,7 @@ module.exports = function(mongoose, config) {
 
 //////////////////////////////
 
-  LimitedPartner.set('autoIndex', true);
+  LimitedPartner.set('autoIndex', false);
   LimitedPartner.on('index', function(err) { console.log('error building limited partner indexes: ' + err); });
 
   LimitedPartner.set('toJSON', { virtuals: true });

package/lib/Organization.js

@@ -8,6 +8,7 @@ module.exports = function(mongoose, config) {
     async = require('async'),
     utils = require('@dhyasama/ffvc-utilities'),
     Schema = mongoose.Schema,
+    Flag = mongoose.model('Flag'),
     Note = mongoose.model('Note'),
 
     customerFunds = [],
@@ -83,6 +84,8 @@ module.exports = function(mongoose, config) {
         resolved: { type: Boolean, default: false }
       },
 
+      flags: [ { type: Schema.ObjectId, ref: 'Flag' } ],
+
       merged: [{ type: Schema.ObjectId, ref: 'Organization' }],
 
       deleted: { type: Boolean, default: false },
@@ -547,6 +550,15 @@ module.exports = function(mongoose, config) {
   // Statics query the entire collection
   //////////////////////////////////////////////////////
 
+  Organization.statics.addFlag = function(organizationId, creatorPersonId, text, cb) {
+
+    Flag.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, organizationId, cb);
+
+  };
+
   Organization.statics.addNote = function(organizationId, creatorPersonId, text, cb) {
 
     Note.createForModel({
@@ -556,6 +568,27 @@ module.exports = function(mongoose, config) {
 
   };
 
+  Organization.statics.deleteFlag = function(flagId, cb) {
+
+    // Delete the flag itself along with reference
+
+    var self = this;
+
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'flags' : [flagId] }
+      }, callback);
+    };
+
+    async.series([
+      Flag.delete.bind(Flag, flagId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
   Organization.statics.deleteNote = function(noteId, cb) {
 
     // Delete the note itself along with any references
@@ -786,21 +819,46 @@ module.exports = function(mongoose, config) {
 
   };
 
+  Organization.statics.getFlags = function getFlags(orgid, cb) {
+
+    var self = this;
+    var query = self.findById(orgid)
+
+    query.select('flags')
+    query.populate({
+      path: 'flags',
+      match: { customer: config.CUSTOMER_ID }
+    })
+    query.deepPopulate([
+      'flags.createdBy'
+    ], {
+      populate: {
+        'flags.createdBy': { select: 'name avatarUrl title' }
+      }
+    })
+    query.sort({'createdOn':-1})
+    query.exec(cb);
+
+  };
+
   Organization.statics.getNotes = function getNotes(orgid, cb) {
 
     var self = this;
     var query = self.findById(orgid)
 
-    query.select('notes')
+    query.select('notes people.person')
+    query.populate('people.person', 'name avatarUrl title calendarEventSummaries')
     query.populate({
       path: 'notes',
       match: { customer: config.CUSTOMER_ID }
     })
     query.deepPopulate([
-      'notes.createdBy'
+      'notes.createdBy',
+      'people.person.calendarEventSummaries.notes.createdBy'
     ], {
       populate: {
-        'notes.createdBy': { select: 'name avatarUrl title' }
+        'notes.createdBy': { select: 'name avatarUrl title' },
+        'people.person.calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' }
       }
     })
     query.sort({'createdOn':-1})

package/lib/Person.js

@@ -8,6 +8,7 @@ module.exports = function(mongoose, config) {
 
     Schema = mongoose.Schema,
     LimitedPartner = mongoose.model('LimitedPartner'),
+    Flag = mongoose.model('Flag'),
     Note = mongoose.model('Note'),
     Crypto = require('@dhyasama/ffvc-crypto'),
     crypto = new Crypto({'key': config.crypto.key}),
@@ -114,6 +115,8 @@ module.exports = function(mongoose, config) {
       resolved: { type: Boolean, default: false }
     },
 
+    flags: [ { type: Schema.ObjectId, ref: 'Flag' } ],
+
     merged: [{ type: Schema.ObjectId, ref: 'Person' }],
 
     deleted: { type: Boolean, default: false },
@@ -747,21 +750,45 @@ module.exports = function(mongoose, config) {
       .exec(cb);
   };
 
+  Person.statics.getFlags = function getFlags(personId, cb) {
+
+    var self = this;
+    var query = self.findById(personId)
+
+    query.select('flags')
+    query.populate({
+      path: 'flags',
+      match: { customer: config.CUSTOMER_ID }
+    })
+    query.deepPopulate([
+      'flags.createdBy'
+    ], {
+      populate: {
+        'flags.createdBy': { select: 'name avatarUrl title' }
+      }
+    })
+    query.sort({'createdOn':-1})
+    query.exec(cb);
+
+  };
+
   Person.statics.getNotes = function getNotes(personId, cb) {
 
     var self = this;
     var query = self.findById(personId)
 
-    query.select('notes')
+    query.select('notes calendarEventSummaries')
     query.populate({
       path: 'notes',
       match: { customer: config.CUSTOMER_ID }
     })
     query.deepPopulate([
-      'notes.createdBy'
+      'notes.createdBy',
+      'calendarEventSummaries.notes.createdBy'
     ], {
       populate: {
-        'notes.createdBy': { select: 'name avatarUrl title' }
+        'notes.createdBy': { select: 'name avatarUrl title' },
+        'calendarEventSummaries.notes.createdBy': { select: 'name avatarUrl title' }
       }
     })
     query.sort({'createdOn':-1})
@@ -991,6 +1018,15 @@ module.exports = function(mongoose, config) {
 
   };
 
+  Person.statics.addFlag = function(personId, creatorPersonId, text, cb) {
+
+    Flag.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, personId, cb);
+
+  };
+
   Person.statics.addNote = function(personId, creatorPersonId, text, cb) {
 
     Note.createForModel({
@@ -1000,6 +1036,27 @@ module.exports = function(mongoose, config) {
 
   };
 
+  Person.statics.deleteFlag = function(flagId, cb) {
+
+    // Delete the flag itself along with reference on person
+
+    var self = this;
+
+    var removeReference = function removeReference(callback) {
+      self.update({}, {
+        $pull: { 'flags' : [flagId] }
+      }, callback);
+    };
+
+    async.series([
+      Flag.delete.bind(Flag, flagId),
+      removeReference
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
   Person.statics.deleteNote = function(noteId, cb) {
 
     // Delete the note itself along with any references on people
@@ -1104,6 +1161,13 @@ module.exports = function(mongoose, config) {
     var self = this;
     var CUSTOMER_ID = config.CUSTOMER_ID;
 
+    // if (self._id.toString() == '5637a9cc281347cc0bc17518') {
+    //   console.log(self);
+    //   console.log(JSON.stringify(_.find(self.calendarEventSummaries, function(item) {
+    //     return item.calendarEventId == '5a81bf645359aef7ff13bfcd';
+    //   }), null, 2));
+    // }
+
     var protectCalendarEventData = function protectCalendarEventData(person) {
 
       if (CUSTOMER_ID == 'GLOBAL_PROCESS') return;

package/package.json

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

package/test/Flag.js

@@ -0,0 +1,247 @@
+"use strict";
+
+var
+
+  should = require("should"),
+  config = require('./config')['test'],
+  _ = require('underscore'),
+  mongoose = require('mongoose'),
+  clearDB = require('mocha-mongoose')(config.db.uri, {noClear: true}),
+  LimitedPartner = mongoose.model('LimitedPartner'),
+  Flag = mongoose.model('Flag'),
+  Organization = mongoose.model('Organization'),
+  Person = mongoose.model('Person');
+
+  var lp, org, person, person2, person3, person4, flagCreator;
+  var accountId = new mongoose.Types.ObjectId();
+  var flagId;
+
+describe('Flag', function() {
+
+  before(function(done) {
+    if (mongoose.connection.db) return done();
+    mongoose.connect(config.db.uri, done);
+  });
+
+  before(function(done) {
+    clearDB(done);
+  });
+
+  before(function(done) {
+
+    lp = new LimitedPartner();
+    lp.name = 'Big LP';
+    lp.slug = 'big-lp';
+
+    LimitedPartner.upsert(lp, 'test', 'lp-full', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      lp = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    org = new Organization();
+    org.name = 'Big Org';
+    org.slug = 'big-org';
+
+    Organization.upsert(org, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      org = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    person = new Person();
+    person.name = {
+      'first': 'Big',
+      'last': 'Person'
+    };
+    person.slug = 'big-person';
+
+    Person.upsert(person, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      person = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    person2 = new Person();
+    person2.name = {
+      'first': 'Another',
+      'last': 'Girl'
+    };
+    person2.slug = 'another-girl';
+
+    Person.upsert(person2, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      person2 = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    person3 = new Person();
+    person3.name = {
+      'first': 'Different',
+      'last': 'Guy'
+    };
+    person3.slug = 'different-guy';
+
+    Person.upsert(person3, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      person3 = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    person4 = new Person();
+    person4.name = {
+      'first': 'Lady',
+      'last': 'Marmaduke'
+    };
+    person4.slug = 'lady-marmaduke';
+
+    Person.upsert(person4, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      person4 = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    flagCreator = new Person();
+    flagCreator.name = {
+      'first': 'George',
+      'last': 'Michael'
+    };
+    flagCreator.slug = 'george-michael';
+
+    Person.upsert(flagCreator, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      flagCreator = result;
+
+      return done();
+
+    });
+
+  });
+
+  it('creates a flag for an organization', function(done) {
+
+    Flag.createForModel({
+      createdBy: flagCreator,
+      text: 'Best flag ever!'
+    }, Organization, org._id, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.flag);
+      should.exist(result.addedTo);
+      result.addedTo.flags.length.should.equal(1);
+
+      flagId = result.addedTo.flags[0];
+
+      return done();
+
+    });
+
+  });
+
+  it('creates a flag for a limited partner', function(done) {
+
+    Flag.createForModel({
+      createdBy: flagCreator,
+      text: 'Best flag ever!'
+    }, LimitedPartner, lp._id, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.flag);
+      should.exist(result.addedTo);
+      result.addedTo.flags.length.should.equal(1);
+
+      return done();
+
+    });
+
+  });
+
+  it('creates a flag for a person', function(done) {
+
+    Flag.createForModel({
+      createdBy: flagCreator,
+      text: 'Best flag ever!'
+    }, Person, person._id, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.flag);
+      should.exist(result.addedTo);
+      result.addedTo.flags.length.should.equal(1);
+
+      return done();
+
+    });
+
+  });
+
+  it('gets a flag by id', function(done) {
+    Flag.getById(flagId, function(err, result) {
+      should.not.exist(err);
+      should.exist(result);
+      result.text.should.equal('Best flag ever!');
+      return done();
+    });
+  });
+
+  it('deletes a flag', function(done) {
+    Flag.delete(flagId, function(err, result) {
+      should.not.exist(err);
+      should.exist(result);
+      return done();
+    });
+  });
+
+});

package/test/Organization.js

@@ -13,6 +13,7 @@ var
 var person, person1, person2;
 var noteId;
 var eventNote;
+var flagId;
 
 describe('Organization', function() {
 
@@ -699,6 +700,36 @@ describe('Organization', function() {
     });
   });
 
+  it('adds a flag', function(done) {
+
+    Organization.addFlag(org4.id, person._id, 'Sweet flag bro!', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.flag);
+      should.exist(result.addedTo);
+      result.addedTo.flags.length.should.equal(1);
+
+      flagId = result.addedTo.flags[0];
+
+      return done();
+
+    });
+
+  });
+
+  it('deletes a flag', function(done) {
+
+    Organization.deleteFlag(flagId, function(err, result) {
+
+      should.not.exist(err);
+
+      return done();
+
+    });
+
+  });
+
   it('adds a note', function(done) {
 
     Organization.addNote(org4.id, person._id, 'Sweet note bro!', function(err, result) {