@dhyasama/totem-models 4.8.0 → 5.0.0

package/index.js

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

package/lib/Deal.js

@@ -0,0 +1,240 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    postFind = require('mongoose-post-find'),
+    _ = require('underscore');
+
+  var Deal = new Schema({
+
+    customer: { type: Schema.ObjectId, ref: 'Organization', required: true },
+
+    organization: { type: Schema.ObjectId, ref: 'Organization', required: true },
+
+    stage: { type: String, trim: true, required: true },
+
+    sources: [{
+      person: { type: Schema.ObjectId, ref: 'Person', required: true },
+      type: { type: String, enum: ['Inbound', 'Outbound', 'Event', 'Referral', 'Other'], required: true }
+    }],
+
+    referrers: [{
+      person: { type: Schema.ObjectId, ref: 'Person', required: true },
+      type: { type: String, enum: ['Founder', 'Investor', 'Service provider', 'Friends and family', 'Limited partner', 'Other'], required: true }
+    }],
+
+    documents: [ { type: Schema.ObjectId, ref: 'Document' } ],
+
+    messages: [ { type: Schema.ObjectId, ref: 'Message' } ],
+
+    fundraise: {
+      amount: { type: Number, default: 0 },
+      valuation: { type: Number, default: 0 },
+      details: [{
+        key: { type: String, trim: true, required: true },
+        value: { type: String, trim: true, required: true },
+      }]
+    },
+
+    resources: [{
+      title: { type: String, trim: true, required: true },
+      link: { type: String, trim: true, required: true },
+    }],
+
+    history: [{
+      timestamp: { type: String, required: true },
+      account: { type: Schema.ObjectId, ref: 'Account', required: true },
+      stage: { type: String, required: true },
+      description: { type: String, trim: true, required: true }
+    }]
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // VIRTUALS
+  // Properties that are not persisted to the database
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // METHODS
+  // Methods operate on a single document that has already been returned
+  // Note that running a method on a document does not save it
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+
+
+  //////////////////////////////////////////////////////
+  // STATICS
+  // Statics operate on the entire collection
+  //////////////////////////////////////////////////////
+
+  Deal.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, deal) {
+
+      if (err) return cb(err, null);
+      else if (!deal) return cb(null, null);
+
+      deal.remove(cb);
+
+    });
+
+  };
+
+  Deal.statics.getAll = function (cb) {
+    this.find({}).exec(cb);
+  };
+
+  Deal.statics.getById = function (id, cb) {
+
+    var self = this;
+
+    self.findOne({
+        '_id': id,
+        'customer': config.CUSTOMER_ID
+      })
+      .populate('organization', 'name logoUrl website websiteAliases')
+      .populate('messages')
+      .populate('sources.person', 'name avatarUrl title')
+      .populate({
+        path: 'documents',
+        match: { customer: config.CUSTOMER_ID }
+      })
+      .populate('history.account', 'person')
+      .exec(cb);
+
+  };
+
+  // Get all deals belonging to a customer
+  Deal.statics.getForCustomer = function (customerId, cb) {
+
+    var self = this;
+
+    self
+      .find({ 'customer': customerId })
+      .populate('organization', 'name logoUrl website websiteAliases')
+      .populate('messages')
+      .populate('sources.person', 'name avatarUrl')
+      .populate({
+        path: 'documents',
+        match: { customer: customerId }
+      })
+      .exec(cb);
+
+  };
+
+  // Get a deal for a org, belonging to current customer
+  Deal.statics.getForOrg = function (orgId, cb) {
+
+    var self = this;
+
+    self
+      .findOne({
+        'organization': orgId,
+        'customer': config.CUSTOMER_ID
+      })
+      .populate('organization', 'name logoUrl website websiteAliases')
+      .populate('messages')
+      .populate('sources.person', 'name avatarUrl title')
+      .populate({
+        path: 'documents',
+        match: { customer: config.CUSTOMER_ID }
+      })
+      .populate('history.account', 'person')
+      .exec(cb);
+  };
+
+  Deal.statics.upsert = function upsert(deal, user, cb) {
+
+    // Deal is dumb and doesn't validate customer stages or duplicate deals. That responsibility is with the org.
+
+    if (!deal) { return cb(new Error('deal is required'), null); }
+
+    var getLastStage = function() {
+
+      if (!deal.history || deal.history.length == 0) return null;
+
+      var history = _.sortBy(deal.history);
+      var last = history[history.length - 1];
+
+      return last.stage;
+
+    };
+
+    var description = '';
+    var lastStage = getLastStage();
+
+    if (lastStage == null) description = 'The deal was created';
+    else if (lastStage != deal.stage) description += 'The deal was updated from ' + lastStage + ' to ' + deal.stage;
+    else description = 'The deal was updated';
+
+    deal.history.push({
+      timestamp: new Date(),
+      account: user,
+      stage: deal.stage,
+      description: description
+    });
+
+    deal.save(cb);
+
+  };
+
+  Deal.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);
+
+    }
+
+  });
+
+
+
+  ///////////////////////////////////////////////////////////////////////////////////////
+  // CONFIG
+  ///////////////////////////////////////////////////////////////////////////////////////
+
+  Deal.set('toJSON', { virtuals: true });
+  Deal.set('autoIndex', false);
+  Deal.on('index', function(err) { console.log('error building deal indexes: ' + err); });
+
+  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  Deal.plugin(deepPopulate);
+
+  mongoose.model('Deal', Deal);
+
+};

package/lib/Document.js

@@ -30,9 +30,7 @@ module.exports = function(mongoose, config) {
       key: { type: String, required: true, trim: true }
     },
 
-    type: { type: String, required: true, enum: ['deals', 'portfolio', 'other'] },
-
-    subtype: { type: String, enum: [null, 'deck'] },
+    type: { type: String, enum: ['deck', 'other'], required: 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,
+    Deal = mongoose.model('Deal'),
     Flag = mongoose.model('Flag'),
     Note = mongoose.model('Note'),
     customerFunds = [],
@@ -33,16 +34,6 @@ module.exports = function(mongoose, config) {
         linkedin: { type: String, trim: true, unique: true, partialFilterExpression : { type :"string" } }
       },
 
-      deals: [{
-        customer: { type: Schema.ObjectId, ref: 'Organization' },
-        status: { type: String, trim: true },
-        history: [{
-          timestamp: { type: String },
-          account: { type: Schema.ObjectId, ref: 'Account' },
-          status: { type: String }
-        }]
-      }],
-
       contact: {
 
         phone: [{
@@ -162,6 +153,9 @@ module.exports = function(mongoose, config) {
       // customer specific (customer id is stored on note)
       notes: [ { type: Schema.ObjectId, ref: 'Note' } ],
 
+      // customer specific (customer id is stored on deal)
+      deals: [ { type: Schema.ObjectId, ref: 'Deal' } ],
+
       // customer specific (customer id is stored on doc)
       documents: [ { type: Schema.ObjectId, ref: 'Document' } ],
 
@@ -683,6 +677,111 @@ module.exports = function(mongoose, config) {
   // Statics query the entire collection
   //////////////////////////////////////////////////////
 
+  Organization.statics.addDeal = function(deal, user, cb) {
+
+    var self = this;
+
+    var checkForDuplicates = function checkForDuplicates(previous, callback) {
+
+      // get org and make sure not already a deal for current customer
+
+      self.getById(utils.getIdAsString(previous.deal, 'organization'), {}, function(err, org) {
+
+        if (err) return callback(err, null);
+        else if (!org) return callback(new Error('Org not found'), null);
+        else if (org.deleted) return callback(new Error('Org deleted'), null);
+
+        var match = _.find(org.deals, function(d) {
+          return utils.getIdAsString(d, 'customer') == deal.customer._id.toString();
+        });
+
+        if (match) return callback(new Error('This org already has a deal for this customer'), null);
+
+        previous.org = org;
+
+        return callback(null, previous);
+
+      });
+
+    };
+
+    var validateStage = function validateStage(previous, callback) {
+
+      // check allowable deal stages against the new deal
+
+      self.findById(deal.customer, function(err, org) {
+
+        if (err) return callback(err, null);
+        else if (!org) return callback(new Error('Customer not found'), null);
+
+        var statuses = org.customer.deals.activeStatuses;
+
+        var match = _.find(statuses, function(status) {
+          return status == previous.deal.stage;
+        });
+
+        if (!match) return callback(new Error('This stage is not valid for this customer'), null);
+
+        return callback(null, previous);
+
+      });
+
+    };
+
+    var createDeal = function createDeal(previous, callback) {
+
+      Deal.upsert(previous.deal, previous.user, function(err, result) {
+
+        if (err) return callback(err, null);
+
+        previous.deal = result;
+
+        return callback(null, previous);
+
+      });
+
+    };
+
+    var addDealToOrg = function addDealToOrg(previous, callback) {
+
+      previous.org.deals.push(previous.deal);
+
+      self.upsert(previous.org, previous.user.username, function(err, result) {
+
+        if (err) return callback(err, null);
+
+        previous.org = result;
+
+        return callback(null, previous);
+
+      });
+
+    };
+
+    var previous = {
+      deal: deal,
+      user: user,
+      org: null
+    };
+
+    async.waterfall([
+      checkForDuplicates.bind(null, previous),
+      validateStage,
+      createDeal,
+      addDealToOrg
+    ], function(err, results) {
+
+      if (err) return cb(err, null);
+
+      return cb(null, {
+        org: results.org,
+        deal: results.deal
+      });
+
+    });
+
+  };
+
   Organization.statics.addFlag = function(organizationId, creatorPersonId, text, cb) {
 
     Flag.createForModel({
@@ -701,6 +800,27 @@ module.exports = function(mongoose, config) {
 
   };
 
+  Organization.statics.deleteDeal = function(dealId, cb) {
+
+    // Delete the deal itself along with any references
+
+    var self = this;
+
+    var removeReferences = function removeReferences(callback) {
+      self.update({}, {
+        $pull: { 'deals' : [dealId] }
+      }, callback);
+    };
+
+    async.series([
+      Deal.delete.bind(Deal, dealId),
+      removeReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
   Organization.statics.deleteFlag = function(flagId, cb) {
 
     // Delete the flag itself along with reference
@@ -981,6 +1101,7 @@ module.exports = function(mongoose, config) {
     if (config.CUSTOMER_ID != 'GLOBAL_PROCESS') lpPopulateOptions.match = { customer: config.CUSTOMER_ID };
 
     var query = self.findById(id);
+
     query.populate('people.person', 'name avatarUrl title contact doNotDisplay');
     query.populate('related', 'name logoUrl');
     query.populate('chairs.first', 'name avatarUrl title');
@@ -989,9 +1110,17 @@ module.exports = function(mongoose, config) {
     query.populate('operating.acquired.public.by', 'name logoUrl');
     query.populate('operating.acquired.private.by', 'name logoUrl');
 
+    query.populate({
+      path: 'deals',
+      match: { customer: config.CUSTOMER_ID }
+    });
+
     if (options.role != 'none') {
       query.populate(lpPopulateOptions);
       query.deepPopulate([
+        'deals.sources.person',
+        'documents',
+        'history.account',
         'lps.fundsInvested.fund'
       ], {
         populate: {
@@ -999,6 +1128,13 @@ module.exports = function(mongoose, config) {
         }
       })
     }
+    else {
+      query.deepPopulate([
+        'deals.sources.person',
+        'documents',
+        'history.account'
+      ]);
+    }
 
     query.exec(cb);
 
@@ -1049,33 +1185,6 @@ module.exports = function(mongoose, config) {
 
   };
 
-  Organization.statics.getDeals = function getDeals(customerId, cb) {
-
-    var self = this;
-
-    self
-      .find({ 'deals.customer': customerId, 'deleted': { $ne: true } })
-      .select('name website websiteAliases deals')
-      .exec(function(err, result) {
-
-        if (err) return cb(err, null);
-
-        result.deals = _.reject(result.deals, function(item) { return !item.customer || item.customer.toString() != customerId.toString(); });
-        result = _.map(result, function(item) {
-          return {
-            name: item.name,
-            website: item.website,
-            websiteAliases: item.websiteAliases,
-            deals: item.deals
-          }
-        });
-
-        return cb(null, result);
-
-      });
-
-  };
-
   Organization.statics.getFlags = function getFlags(orgid, cb) {
 
     var self = this;
@@ -1632,7 +1741,6 @@ module.exports = function(mongoose, config) {
     doc.chairs = _.reject(doc.chairs, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
     doc.operating.acquired.private = _.find(doc.operating.acquired.private, function(item) { return !item.customer || item.customer.toString() == CUSTOMER_ID; });
     doc.operating.closed.private = _.find(doc.operating.closed.private, function(item) { return !item.customer || item.customer.toString() == CUSTOMER_ID; });
-    doc.deals = _.reject(doc.deals, function(item) { return !item.customer || item.customer.toString() != CUSTOMER_ID; });
 
     // people
     _.each(doc.people, function(person) {

package/package.json

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

package/test/Deal.js

@@ -0,0 +1,222 @@
+"use strict";
+
+var
+
+  should = require("should"),
+  config = require('./config')['test'],
+  _ = require('underscore'),
+  mongoose = require('mongoose'),
+  clearDB = require('mocha-mongoose')(config.db.uri, {noClear: true}),
+  Account = mongoose.model('Account'),
+  Deal = mongoose.model('Deal'),
+  Organization = mongoose.model('Organization');
+
+var org;
+var customer;
+var dealId;
+var account;
+
+describe('Deal', function() {
+
+  before(function(done) {
+    if (mongoose.connection.db) return done();
+    mongoose.connect(config.db.uri, done);
+  });
+
+  before(function(done) {
+    clearDB(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) {
+
+    customer = new Organization();
+    customer.name = 'HUGE VC';
+    customer.slug = 'huge-vc';
+
+    Organization.upsert(customer, 'test', function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      customer = result;
+
+      config.CUSTOMER_ID = customer._id.toString();
+
+      return done();
+
+    });
+
+  });
+
+  before(function (done) {
+
+    account = new Account();
+    account.username = 'test-user';
+    account.email = 'test@totemvc.com';
+    account.person = new mongoose.Types.ObjectId();
+
+    Account.upsert(account, function (err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      account = result;
+
+      return done();
+
+    });
+
+  });
+
+  it('creates a deal', function(done) {
+
+    var deal = new Deal({
+      customer: customer,
+      organization: org,
+      stage: 'New'
+    });
+
+    Deal.upsert(deal, account, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      dealId = result._id;
+
+      return done();
+
+    });
+
+  });
+
+  it('gets a deal by id', function(done) {
+    Deal.getById(dealId, function(err, result) {
+      should.not.exist(err);
+      should.exist(result);
+      result._id.toString().should.equal(dealId.toString());
+      return done();
+    });
+  });
+
+  it('adds a document to a deal', function(done) {
+
+    Deal.getById(dealId, function(err, deal) {
+
+      should.not.exist(err);
+      should.exist(deal);
+
+      deal.documents.push(new mongoose.Types.ObjectId());
+
+      Deal.upsert(deal, account, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        return done();
+
+      });
+
+    });
+
+  });
+
+  it('changes the deal stage', function(done) {
+
+    Deal.getById(dealId, function(err, deal) {
+
+      should.not.exist(err);
+      should.exist(deal);
+
+      deal.stage = 'Pass';
+
+      Deal.upsert(deal, account, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+        return done();
+
+      });
+
+    });
+
+  });
+
+  it('gets all deals for a customer', function(done) {
+
+    var d = new Deal({
+      customer: customer,
+      organization: new mongoose.Types.ObjectId(),
+      stage: 'New'
+    });
+
+    Deal.upsert(d, account, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      var d = new Deal({
+        customer: new mongoose.Types.ObjectId(),
+        organization: new mongoose.Types.ObjectId(),
+        stage: 'New'
+      });
+
+      Deal.upsert(d, account, function(err, result) {
+
+        should.not.exist(err);
+        should.exist(result);
+
+        Deal.getForCustomer(config.CUSTOMER_ID, function(err, result) {
+          should.not.exist(err);
+          should.exist(result)
+          result.length.should.equal(2);
+          return done();
+        });
+
+      });
+
+    });
+
+  });
+
+  it('gets all deals', function(done) {
+
+    var temp = config.CUSTOMER_ID;
+    config.CUSTOMER_ID = 'GLOBAL_PROCESS';
+
+    Deal.getAll(function(err, result) {
+      should.not.exist(err);
+      should.exist(result)
+      result.length.should.equal(3);
+      config.CUSTOMER_ID = temp;
+      return done();
+    });
+
+  });
+
+  it('deletes a deal', function(done) {
+    Deal.delete(dealId, function(err, result) {
+      should.not.exist(err);
+      should.exist(result);
+      return done();
+    });
+  });
+
+});

package/test/Document.js

@@ -7,13 +7,15 @@ var
   _ = require('underscore'),
   mongoose = require('mongoose'),
   clearDB = require('mocha-mongoose')(config.db.uri, {noClear: true}),
+  Account = mongoose.model('Account'),
+  Deal = mongoose.model('Deal'),
   Document = mongoose.model('Document'),
   Interaction = mongoose.model('Interaction'),
   Message = mongoose.model('Message'),
   Organization = mongoose.model('Organization'),
   Person = mongoose.model('Person');
 
-var interaction, message, org, person, documentCreator, documentId;
+var deal, account, interaction, message, org, person, documentCreator, documentId;
 
 describe('Document', function() {
 
@@ -96,6 +98,45 @@ describe('Document', function() {
 
   });
 
+  before(function (done) {
+
+    account = new Account();
+    account.username = 'test-user';
+    account.email = 'test@totemvc.com';
+    account.person = new mongoose.Types.ObjectId();
+
+    Account.upsert(account, function (err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+
+      account = result;
+
+      return done();
+
+    });
+
+  });
+
+  before(function(done) {
+
+    deal = new Deal();
+    deal.customer = new mongoose.Types.ObjectId();
+    deal.organization = new mongoose.Types.ObjectId();
+    deal.stage = 'New';
+
+    Deal.upsert(deal, account, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      deal = result;
+
+      return done();
+
+    });
+
+  });
+
   before(function(done) {
 
     person = new Person();
@@ -177,7 +218,7 @@ describe('Document', function() {
         bucket: 'totem',
         key: 'docs'
       },
-      type: 'deals'
+      type: 'other'
     }, Message, message._id, function(err, result) {
 
       should.not.exist(err);
@@ -204,7 +245,7 @@ describe('Document', function() {
         bucket: 'totem',
         key: 'docs'
       },
-      type: 'portfolio'
+      type: 'other'
     }, Organization, org._id, function(err, result) {
 
       should.not.exist(err);
@@ -248,6 +289,33 @@ describe('Document', function() {
 
   });
 
+  it('creates a document for a deal', function(done) {
+
+    Document.createForModel({
+      customer: config.CUSTOMER_ID,
+      createdBy: documentCreator,
+      name: 'test.pdf',
+      contentType: 'application/pdf',
+      contentLength: 54321,
+      s3: {
+        bucket: 'totem',
+        key: 'docs'
+      },
+      type: 'deck'
+    }, Deal, deal._id, function(err, result) {
+
+      should.not.exist(err);
+      should.exist(result);
+      should.exist(result.document);
+      should.exist(result.addedTo);
+      result.addedTo.documents.length.should.equal(1);
+
+      return done();
+
+    });
+
+  });
+
   it('gets a document by id', function(done) {
     Document.getById(documentId, function(err, result) {
       should.not.exist(err);

package/test/Organization.js

@@ -11,17 +11,17 @@ var
   Person = mongoose.model('Person'),
   LimitedPartner = mongoose.model('LimitedPartner'),
   Fund = mongoose.model('Fund'),
-  Note = mongoose.model('Note'),
+  Deal = mongoose.model('Deal'),
   Account = mongoose.model('Account');
 
 var person, person1, person2;
 var noteId;
-var eventNote;
 var flagId;
 var someOtherFund;
 var someOtherLp;
 var account;
 var customer1, customer2;
+var deal;
 
 describe('Organization', function() {
 
@@ -1131,8 +1131,6 @@ describe('Organization', function() {
 
   describe('Deals', function() {
 
-    var org;
-
     it('gets deal statuses for a customer', function(done) {
 
       var statuses = customer1.customer.deals.activeStatuses;
@@ -1148,29 +1146,23 @@ describe('Organization', function() {
 
     it('adds a deal', function(done) {
 
-      org = new Organization();
-      org.name = 'New Co';
-      org.slug = 'new-co';
-      org.website = 'new.co';
+      config.CUSTOMER_ID = customer1._id.toString();
 
-      Organization.upsert(org, 'test-user', function(err, result) {
+      deal = new Deal({
+        customer: customer1,
+        organization: org3,
+        stage: 'New'
+      });
+
+      Organization.addDeal(deal, account, function(err, result) {
 
         should.not.exist(err);
         should.exist(result);
+        result.org.deals.length.should.equal(1);
 
-        result.addDeal('New', customer1, account);
-
-        Organization.upsert(result, 'test-user', function(err, result) {
-
-          should.not.exist(err);
-          should.exist(result);
-          result.deals.length.should.equal(1);
-
-          org = result;
-
-          return done();
+        deal = result.deal;
 
-        });
+        return done();
 
       });
 
@@ -1178,60 +1170,65 @@ describe('Organization', function() {
 
     it('adds a deal again', function(done) {
 
-      var threwError = false;
+      var d = new Deal({
+        customer: customer1,
+        organization: org3,
+        stage: 'New'
+      });
+
+      Organization.addDeal(d, account, function(err, result) {
 
-      try {
-        org.addDeal('Pass', customer1, account);
-      }
-      catch (err) {
-        threwError = true;
-      }
+        should.exist(err);
+        should.not.exist(result);
 
-      threwError.should.equal(false);
-      org.deals.length.should.equal(1);
-      org.deals[0].status.should.equal('Pass');
+        return done();
 
-      return done();
+      });
 
     });
 
     it('adds a deal with an inactive state', function(done) {
 
-      var threwError = false;
+      var d = new Deal({
+        customer: customer1,
+        organization: org4,
+        stage: 'Pending'
+      });
 
-      try {
-        org.addDeal('Pending', customer1, account);
-      }
-      catch (err) {
-        threwError = true;
-      }
+      Organization.addDeal(d, account, function(err, result) {
 
-      threwError.should.equal(true);
+        should.exist(err);
+        should.not.exist(result);
 
-      return done();
+        return done();
+
+      });
 
     });
 
     it('adds a deal for another customer', function(done) {
 
+      config.CUSTOMER_ID = customer2._id.toString();
+
       var org2 = new Organization();
       org2.name = 'Newest Co';
       org2.slug = 'newest-co';
 
-      Organization.upsert(org2, 'test-user', function(err, result) {
+      Organization.upsert(org2, 'test-user', function(err, result1) {
 
         should.not.exist(err);
-        should.exist(result);
+        should.exist(result1);
 
-        result.addDeal('Pass', customer2, account);
+        var d = new Deal({
+          customer: customer2,
+          organization: result1,
+          stage: 'Pass'
+        });
 
-        Organization.upsert(result, 'test-user', function(err, result) {
+        Organization.addDeal(d, account, function(err, result2) {
 
           should.not.exist(err);
-          should.exist(result);
-          result.deals.length.should.equal(1);
-
-          org = result;
+          should.exist(result2);
 
           return done();
 
@@ -1241,45 +1238,11 @@ describe('Organization', function() {
 
     });
 
-    it('gets deals for non-customer process', function(done) {
-
-      var temp = config.CUSTOMER_ID;
-      config.CUSTOMER_ID = 'GLOBAL_PROCESS';
-
-      Organization.getDeals(customer1._id, function(err, result) {
-
-        should.not.exist(err);
-        should.exist(result);
-        result.length.should.equal(1);
-        result[0].name.should.equal('New Co');
-        result[0].deals.length.should.equal(1);
-        result[0].deals[0].customer.toString().should.equal(customer1._id.toString());
-        result[0].deals[0].status.should.equal('New');
-
-        config.CUSTOMER_ID = temp;
-
-        return done();
-
-      });
-
-    });
-
-    it('gets deals for a customer', function(done) {
-
-      var temp = config.CUSTOMER_ID;
-      config.CUSTOMER_ID = customer1._id.toString();
+    it('deletes a deal', function (done) {
 
-      Organization.getDeals(customer1._id, function(err, result) {
+      Organization.deleteDeal(deal._id, function (err, result) {
 
         should.not.exist(err);
-        should.exist(result);
-        result.length.should.equal(1);
-        result[0].name.should.equal('New Co');
-        result[0].deals.length.should.equal(1);
-        result[0].deals[0].customer.toString().should.equal(customer1._id.toString());
-        result[0].deals[0].status.should.equal('New');
-
-        config.CUSTOMER_ID = temp;
 
         return done();