@dhyasama/totem-models 9.31.0 → 9.32.0

package/index.js

@@ -50,6 +50,8 @@ var bootstrap = function(mongoose, config) {
   require('./lib/CalendarEvent.js')(mongoose, config);
   require('./lib/CapTable.js')(mongoose, config);
   require('./lib/Document.js')(mongoose, config);
+  require('./lib/Event.js')(mongoose, config);
+  require('./lib/EventAttendee.js')(mongoose, config);
   require('./lib/Financials.js')(mongoose, config);
   require('./lib/Interaction.js')(mongoose, config);
   require('./lib/Investment.js')(mongoose, config);

package/lib/Event.js

@@ -0,0 +1,127 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  const _ = require('underscore');
+  const Schema = mongoose.Schema;
+
+  const Event = new Schema({
+
+    // The customer this event belongs to
+    customer: {
+      type: Schema.ObjectId,
+      ref: 'Organization',
+      required: true,
+      index: true
+    },
+
+    // The provider the event is hosted on
+    provider: {
+      type: String,
+      required: true,
+      enum: [
+        'Splash',
+      ],
+      default: 'Splash'
+    },
+
+    // Event information
+    EventId: { type: String, required: true },
+    EventTitle: { type: String, required: true },
+    EventStartDate: { type: Date, required: true },
+    EventEndDate: { type: Date, required: false },
+    EventTimezone: { type: String, required: true, default: 'America/New_York' },
+    EventUrl: { type: String, required: false }
+
+  });
+
+  Event.virtual('Attendees', {
+    ref: 'EventAttendee',
+    localField: '_id',
+    foreignField: 'Event',
+    justOne: true // for many-to-1 relationships
+  });
+
+  Event.statics.delete = function (id, options, cb) {
+
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!id) { return cb(new Error('id is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+
+    self.findByIdAndRemove(id, cb);
+
+  };
+
+  // Get a single event
+  // Double check customer id
+  // Optionally populate customer
+  Event.statics.getById = function (id, options, cb) {
+
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!id) { return cb(new Error('id is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+    if (!options.CUSTOMER_ID) { return cb(new Error('options.CUSTOMER_ID is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
+
+    let query = self.findOne({
+      '_id': id,
+      'customer': options.CUSTOMER_ID
+    });
+
+    if (options.populate) {
+      query.populate('Attendees');
+      query.populate('customer');
+    }
+
+    query.exec(cb);
+
+  };
+
+  // Get all events a customer has held
+  // Optionally populate customer
+  Event.statics.list = function(customerId, options, cb) {
+
+    const self = this;
+
+    if (!cb) throw new Error('callback is required');
+    if (!options) options = {};
+    if (!customerId) throw new Error('customerId is required');
+    if (!mongoose.Types.ObjectId.isValid(customerId)) { return cb(new Error('customerId is not a valid ObjectId'), null); }
+
+    let query = self.find({ customer: customerId });
+
+    if (options.populate) {
+      query.populate('Attendees');
+      query.populate('customer');
+    }
+
+    query.exec(cb);
+
+  };
+
+  // Create or update an event
+  Event.statics.upsert = function(event, options, cb) {
+
+    if (!cb) throw new Error('cb is required');
+    if (!event) throw new Error('event is required');
+    if (!options) { return cb(new Error('options is required'), null); }
+
+    event.save(cb);
+
+  };
+
+  Event.set('usePushEach', true);
+  Event.set('autoIndex', false);
+  Event.set('toJSON', { virtuals: true });
+  Event.set('toObject', { virtuals: true });
+  Event.on('index', function(err) { console.log('error building event indexes: ' + err); });
+
+  mongoose.model('Event', Event);
+
+};

package/lib/EventAttendee.js

@@ -0,0 +1,140 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  const Schema = mongoose.Schema;
+
+  const EventAttendee = new Schema({
+
+    Event: {
+      type: Schema.ObjectId,
+      ref: 'Event',
+      required: true,
+      index: true
+    },
+
+    Email: { type: String, required: true, index: true },
+
+    ProviderEventId: { type: String, required: true },
+
+    ProviderContactId: { type: String, required: true },
+
+    ProviderGuestListStatus: {
+      type: String,
+      required: true,
+      enum: [
+        'invited',
+        'rsvp_yes',
+        'rsvp_no',
+        'checkin_yes'
+      ]
+    }
+
+  });
+
+  // Delete an attendee of an event
+  EventAttendee.statics.delete = function (eventId, email, options, cb) {
+
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!eventId) { return cb(new Error('eventId is required'), null); }
+    if (!mongoose.Types.ObjectId.isValid(eventId)) { return cb(new Error('eventId is not a valid ObjectId'), null); }
+    if (!email) { return cb(new Error('email is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+
+    self.findOneAndRemove({ Event: eventId, Email: email }, cb);
+
+  };
+
+  // DO NOT IMPLEMENT
+  // Use Event, with populate true, to get the attendees of an event
+  // Having it here would be redundant
+  // Get all the attendees for an event
+  // EventAttendee.statics.listAllAttendeesOfEvent = function (eventId, options, cb) {
+  //
+  //
+  //
+  // };
+
+  // Get all the events an attendee attended
+  // Email can be a single email or an array of emails
+  // Optionally populate the event
+  EventAttendee.statics.listAllEventsForAttendee = function (email, options, cb) {
+
+    const self = this;
+
+    if (!cb) { throw new Error('cb is required'); }
+    if (!email) { return cb(new Error('email is required'), null); }
+    if (!options) { return cb(new Error('options is required'), null); }
+
+
+    // todo - filter customer
+
+
+
+    let params;
+
+    if (Array.isArray(email)) {
+      params = { Email: { $in : email }};
+    }
+    else {
+      params = { Email: email };
+    }
+
+    let query = self.find(params);
+
+    if (options.populate) {
+      query.populate('Event');
+    }
+
+    query.exec(cb);
+
+  };
+
+  // Update status for an attendee of an event
+  EventAttendee.statics.setGuestListStatus = function(eventId, email, status, options, cb) {
+
+    const self = this;
+
+    if (!cb) throw new Error('cb is required');
+    if (!eventId) throw new Error('eventAttendee is required');
+    if (!mongoose.Types.ObjectId.isValid(eventId)) { return cb(new Error('eventId is not a valid ObjectId'), null); }
+    if (!email) throw new Error('eventAttendee is required');
+    if (!status) throw new Error('eventAttendee is required');
+    if (!options) { return cb(new Error('options is required'), null); }
+
+    const conditions = {
+      Event: eventId,
+      Email: email
+    };
+
+    const update = {
+      $set: {
+        'ProviderGuestListStatus' : status
+      }
+    };
+
+    self.findOneAndUpdate(conditions, update, { upsert: false, new: true }, cb);
+
+  };
+
+  // Update an attendee of an event
+  EventAttendee.statics.upsert = function(eventAttendee, options, cb) {
+
+    if (!cb) throw new Error('cb is required');
+    if (!eventAttendee) throw new Error('eventAttendee is required');
+    if (!options) { return cb(new Error('options is required'), null); }
+
+    eventAttendee.save(cb);
+
+  };
+
+  EventAttendee.set('usePushEach', true);
+  EventAttendee.set('autoIndex', false);
+
+  EventAttendee.on('index', function(err) { console.log('error building event attendee indexes: ' + err); });
+
+  mongoose.model('EventAttendee', EventAttendee);
+
+};

package/package.json

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

package/test/Event.js

@@ -0,0 +1,195 @@
+"use strict";
+
+var
+
+  should = require("should"),
+  config = require('./config')['test'],
+  mongoose = require('mongoose'),
+  clearDB = require('mocha-mongoose')(config.db.uri, {noClear: true}),
+  Event = mongoose.model('Event'),
+  EventAttendee = mongoose.model('EventAttendee');
+
+const customerOneId = new mongoose.Types.ObjectId();
+const customerTwoId = new mongoose.Types.ObjectId();
+
+let customerOneEvent;
+let customerTwoEvent;
+
+describe('Event', function() {
+
+  before(function(done) {
+
+    console.log('DB url:', config.db.uri);
+
+    if (config.db.uri.indexOf('test') === -1) {
+      console.log('Not test db, shutting down');
+      process.exit();
+    }
+    else {
+      if (mongoose.connection.db) { return done(); }
+      else { mongoose.connect(config.db.uri, done); }
+    }
+
+  });
+
+  before(function(done) {
+     clearDB(done);
+  });
+
+  it('adds an event for a customer', function(done) {
+
+    let e = new Event();
+    e.customer = customerOneId;
+    e.EventId = 'my-funny-id';
+    e.EventTitle = 'My Funny Event';
+    e.EventStartDate = new Date();
+
+    Event.upsert(e, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      customerOneEvent = result;
+
+      return done();
+
+    });
+
+  });
+
+  it('adds an event for a different customer', function(done) {
+
+    let e = new Event();
+    e.customer = customerTwoId;
+    e.EventId = 'my-hilarious-id';
+    e.EventTitle = 'My Hilarious Event';
+    e.EventStartDate = new Date();
+
+    Event.upsert(e, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      customerTwoEvent = result;
+
+      return done();
+
+    });
+
+  });
+
+  it('gets an event', function(done) {
+
+    Event.getById(customerOneEvent._id, { CUSTOMER_ID: customerOneId }, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      result._id.toString().should.equal(customerOneEvent._id.toString());
+
+      return done();
+
+    });
+
+  });
+
+  it('gets the attendees of an event', function(done) {
+
+    let attendee = new EventAttendee();
+    attendee.Event = customerOneEvent;
+    attendee.Email = 'jason@totemvc.com';
+    attendee.ProviderEventId = 'my-funny-id';
+    attendee.ProviderContactId = 'abc123';
+    attendee.ProviderGuestListStatus = 'invited';
+
+    EventAttendee.upsert(attendee, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      Event.getById(customerOneEvent._id, { CUSTOMER_ID: customerOneId, populate: true }, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        should.exist(result.Attendees);
+
+        return done();
+
+      });
+
+    });
+
+  });
+
+  it('updates an event', function(done) {
+
+    const newTitle = 'My Event Funnier Event';
+
+    customerOneEvent.EventTitle = newTitle;
+
+    Event.upsert(customerOneEvent, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.EventTitle);
+      result.EventTitle.should.equal(newTitle);
+
+      return done();
+
+    });
+
+  });
+
+  it('cannot get an event belonging to another customer', function(done) {
+
+    Event.getById(customerOneEvent._id, { CUSTOMER_ID: customerTwoId }, function(err, result) {
+
+      should.not.exist(err);
+      should.not.exist(result);
+
+      return done();
+
+    });
+
+  });
+
+  it('removes an event', function(done) {
+
+    Event.delete(customerTwoEvent._id, {}, function(err, result) {
+
+      should.not.exist(err);
+
+      return done();
+
+    });
+
+  });
+
+  it('gets all events for a customer', function(done) {
+
+    Event.list(customerOneId, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      result.length.should.equal(1);
+
+      return done();
+
+    });
+
+  });
+
+  it('gets all events for a customer that does not have events', function(done) {
+
+    Event.list(customerTwoId, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      result.length.should.equal(0);
+
+      return done();
+
+    });
+
+  });
+
+});

package/test/EventAttendee.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var
+
+  should = require("should"),
+  config = require('./config')['test'],
+  mongoose = require('mongoose'),
+  clearDB = require('mocha-mongoose')(config.db.uri, {noClear: true}),
+  Event = mongoose.model('Event'),
+  EventAttendee = mongoose.model('EventAttendee');
+
+const customerOneId = new mongoose.Types.ObjectId();
+
+let customerOneEvent;
+let customerTwoEvent;
+let attendeeOne;
+
+describe.only('EventAttendee', function() {
+
+  before(function(done) {
+
+    console.log('DB url:', config.db.uri);
+
+    if (config.db.uri.indexOf('test') === -1) {
+      console.log('Not test db, shutting down');
+      process.exit();
+    }
+    else {
+      if (mongoose.connection.db) { return done(); }
+      else { mongoose.connect(config.db.uri, done); }
+    }
+
+  });
+
+  before(function(done) {
+     clearDB(done);
+  });
+
+  before(function(done) {
+
+    let e = new Event();
+    e.customer = customerOneId;
+    e.EventId = 'my-funny-id';
+    e.EventTitle = 'My Funny Event';
+    e.EventStartDate = new Date();
+
+    Event.upsert(e, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      customerOneEvent = result;
+
+      let e = new Event();
+      e.customer = customerOneId;
+      e.EventId = 'my-boring-id';
+      e.EventTitle = 'My Boring Event';
+      e.EventStartDate = new Date();
+
+      Event.upsert(e, {}, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        customerTwoEvent = result;
+
+        return done();
+
+      });
+
+    });
+
+  });
+
+  it('adds an attendee to an event', function(done) {
+
+    let attendee = new EventAttendee();
+    attendee.Event = customerOneEvent;
+    attendee.Email = 'jason@totemvc.com';
+    attendee.ProviderEventId = 'my-funny-id';
+    attendee.ProviderContactId = 'abc123';
+    attendee.ProviderGuestListStatus = 'invited';
+
+    EventAttendee.upsert(attendee, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      attendeeOne = result;
+
+      return done();
+
+    });
+
+  });
+
+  it('adds a second attendee to an event', function(done) {
+
+    let attendee = new EventAttendee();
+    attendee.Event = customerOneEvent;
+    attendee.Email = 'dhyasama@gmail.com';
+    attendee.ProviderEventId = 'my-funny-id';
+    attendee.ProviderContactId = 'def456';
+    attendee.ProviderGuestListStatus = 'rsvp_yes';
+
+    EventAttendee.upsert(attendee, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      return done();
+
+    });
+
+  });
+
+  it('gets all the events for an attendee with a single email', function(done) {
+
+    EventAttendee.listAllEventsForAttendee('dhyasama@gmail.com', { populate: true }, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      result.length.should.equal(1);
+      should.exist(result[0].Event);
+      should.exist(result[0].Event.EventTitle);
+      result[0].Event.EventTitle.should.equal('My Funny Event');
+
+      return done();
+
+    });
+
+  });
+
+  it('gets all the events for an attendee with two emails', function(done) {
+
+    EventAttendee.listAllEventsForAttendee(['dhyasama@gmail.com', 'dhyasama+test@gmail.com'], { populate: true }, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      result.length.should.equal(1);
+      should.exist(result[0].Event);
+      should.exist(result[0].Event.EventTitle);
+      result[0].Event.EventTitle.should.equal('My Funny Event');
+
+      return done();
+
+    });
+
+  });
+
+  it('updates an event attendee', function(done) {
+
+    attendeeOne.ProviderContactId = 'ghi789';
+
+    EventAttendee.upsert(attendeeOne, {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.ProviderContactId);
+      result.ProviderContactId.should.equal('ghi789');
+
+      attendeeOne = result;
+
+      return done();
+
+    });
+
+  });
+
+  it('updates an event status', function(done) {
+
+    EventAttendee.setGuestListStatus(customerOneEvent._id, 'jason@totemvc.com', 'rsvp_yes', {}, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.ProviderGuestListStatus);
+      result.ProviderGuestListStatus.should.equal('rsvp_yes');
+
+      attendeeOne = result;
+
+      return done();
+
+    });
+
+  });
+
+});

package/test/Round.js

@@ -18,9 +18,9 @@ var personid = new mongoose.Types.ObjectId();
 var fundid = new mongoose.Types.ObjectId();
 var organization, organization2, fund, person, investment, investment2;
 
-describe.only('Rounds', function() {
+describe('Rounds', function() {
 
-  config.db.uri = 'mongodb://jason:T576G150HPXLA5q4BJ2o2zj747B5030x@production-shard-00-00-gv0f3.mongodb.net:27017,production-shard-00-01-gv0f3.mongodb.net:27017,production-shard-00-02-gv0f3.mongodb.net:27017/production?replicaSet=Production-shard-0&ssl=true&authSource=admin'
+  //config.db.uri = 'mongodb://jason:T576G150HPXLA5q4BJ2o2zj747B5030x@production-shard-00-00-gv0f3.mongodb.net:27017,production-shard-00-01-gv0f3.mongodb.net:27017,production-shard-00-02-gv0f3.mongodb.net:27017/production?replicaSet=Production-shard-0&ssl=true&authSource=admin'
 
   before(function(done) {
     if (mongoose.connection.db) return done();