@dhyasama/totem-models 1.0.0

package/lib/Person.js

@@ -0,0 +1,1163 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var customerCompanyIds = [];
+
+  var
+
+    Schema = mongoose.Schema,
+    LimitedPartner = mongoose.model('LimitedPartner'),
+    Note = mongoose.model('Note'),
+    Crypto = require('@dhyasama/ffvc-crypto'),
+    crypto = new Crypto({'key': config.crypto.key}),
+    domain = config.domain,
+    utils = require('@dhyasama/ffvc-utilities'),
+    async = require('async'),
+    env = process.env.NODE_ENV || 'development',
+    bcrypt = require('bcrypt'),
+    _ = require('underscore'),
+    phoneFormatter = require('phone-formatter'),
+    PhoneNumber = require( 'awesome-phonenumber'),
+    validator = require('validator'),
+    escapeStringRegexp = require('escape-string-regexp');
+
+  var Person = new Schema({
+
+    name: {
+      first: { type: String, default: '', index: true },
+      last: { type: String, default: '', index: true }
+    },
+
+    slug: { type: String, required: true, unique: true, sparse: false, trim: true, lowercase: true },
+
+    contact: {
+
+      phone: [{
+        type: { type: String, enum: ['home', 'work', 'assistant', 'mobile', 'other'] },
+        number: { type: String, default: '' },
+        primary: { type: Boolean, default: false }
+      }],
+
+      email: [{
+        type: { type: String, enum: ['personal', 'work', 'assistant', 'other'] },
+        email: { type: String, default: '', es_type: 'text' },
+        primary: { type: Boolean, default: false }
+      }],
+
+      address: [{
+        type: { type: String, default: '' },
+        street: { type: String, default: '' },
+        suite: { type: String, default: '' },
+        city: { type: String, default: '' },
+        state: { type: String, default: '' },
+        country: { type: String, default: '' },
+        postalCode: { type: String, default: '' },
+        primary: { type: Boolean, default: false }
+      }]
+
+    },
+
+    title: { type: String, default: null, trim: true },
+
+    birthday: { type: String, default: null, trim: true },
+
+    bio: { type: String, default: null, trim: true },
+
+    website: { type: String, default: null, required: false, trim: true, lowercase: true },
+
+    crunchbase: {
+      uuid: { type: String, unique: true, required: false, sparse: true, trim: true }
+    },
+
+    vCardUrl: { type: String, default: null, trim: true },
+
+    social: {
+      twitter: { type: String, trim: true, unique: true, sparse: true },
+      facebook: { type: String, trim: true, unique: true, sparse: true },
+      linkedin: { type: String, trim: true, unique: true, sparse: true }
+    },
+
+    avatarUrl: { type: String, default: null, trim: true },
+
+    sources: [{
+      _id: false,
+      person: { type: Schema.ObjectId, ref: 'Person' },
+      customer: { type: Schema.ObjectId, ref: 'Organization' },
+      interactions: {
+        calendar: { type: Number, required: false, default: 0 },
+        email: { type: Number, required: false, default: 0 }
+      }
+    }],
+
+    notes: [ { type: Schema.ObjectId, ref: 'Note' } ],
+
+    // this only relates to access for lps
+    syndication: {
+      notify: { type: Boolean, default: false }
+    },
+
+    // this only relates to access for lps
+    subscriptions: [{ id: { type: Schema.ObjectId, required: false, default: null }}],
+
+    account: { type: Schema.ObjectId, ref: 'Account', required: false },
+
+    entered: {
+      by: { type: String, default: null, trim: true },
+      on: { type: Date, default: Date.now }
+    },
+
+    flagged: {
+      by: { type: String, default: null, trim: true },
+      on: { type: Date, default: Date.now },
+      text: { type: String, default: null, trim: true },
+      resolved: { type: Boolean, default: false }
+    },
+
+    merged: [{ type: Schema.ObjectId, ref: 'Person' }],
+
+    deleted: { type: Boolean, default: false },
+
+    aliases: [ { type: String, trim: true } ],
+
+    related: [{ type: Schema.ObjectId, ref: 'Person' }],
+
+    calendarEventSummaries: [
+      {
+        calendarEventId: { type: Schema.ObjectId, ref: 'CalendarEvent', required: true },
+        providerEventId: { type: String, required: true, index: true, trim: true },
+        totemCustomerId: { type: Schema.ObjectId, ref: 'Organization', required: true },
+        summary: { type: String, required: true, trim: true },
+        startTime: { type: Date },
+        attendees: {
+          internal: [{ type: Schema.ObjectId, ref: 'Person' }],
+          external: [{ type: Schema.ObjectId,  ref: 'Person' }]
+        },
+        notes: [ { type: Schema.ObjectId, ref: 'Note' } ]
+      }
+    ]
+
+  });
+
+  /////////////
+
+  Person.virtual('name.full').get(function () {
+    return this.name.first + ' ' + this.name.last;
+  });
+
+  Person.virtual('avatar').get(function() {
+    return this.avatarUrl || domain + '/media/moustache.jpg';
+  });
+
+  Person.virtual('email.primary').get(function () {
+    var primary = _.find(this.contact.email, function(email) {
+      return email.primary;
+    });
+    return primary ? primary.email : '';
+  });
+
+  Person.virtual('phone.primary').get(function () {
+    var primary = _.find(this.contact.phone, function(phone) {
+      return phone.primary;
+    });
+    return primary ? primary.number : '';
+  });
+
+  Person.virtual('interactions.count').get(function () {
+
+    // handle missing doc data
+    this.sources = this.sources || [];
+
+    var calendarCount = 0;
+    var emailCount = 0;
+
+    _.each(this.sources, function(source) {
+
+      // Only count interactions for the current customer
+      // A universal interaction count isn't useful
+      var cid = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
+
+      if (cid.toString() == config.CUSTOMER_ID) {
+        source.interactions = source.interactions || {};
+        calendarCount += source.interactions.calendar || 0;
+        emailCount += source.interactions.email || 0;
+      }
+
+    });
+
+    return calendarCount + emailCount;
+
+  });
+
+  Person.virtual('allNotes').get(function () {
+
+    // combine direct person notes and notes from events this person attended
+    // sort reverse chronologically
+
+    var personNotes = this.notes || [];
+    personNotes = _.compact(personNotes);
+
+    var eventNotes = _.pluck(this.calendarEventSummaries || [], 'notes');
+    eventNotes = _.flatten(eventNotes);
+    eventNotes = _.compact(eventNotes);
+
+    var result = _.sortBy(personNotes.concat(eventNotes), 'createdOn');
+
+    return result.reverse();
+
+  });
+
+  /////////////
+
+  Person.methods.addMerged = function(id) {
+    if (this.merged.indexOf(id) == -1) {
+      this.merged.push(id);
+      return true;
+    }
+    else {
+      return false;
+    }
+  };
+
+  Person.methods.deletePerson = function() {
+    this.deleted = true;
+  };
+
+  Person.methods.relatePerson = function(id) {
+    this.related.push(id);
+  };
+
+  Person.methods.addChairPos = function(chairObj, orgId) {
+
+    var chair = {
+      company: orgId,
+      start: ''
+    };
+
+    switch(chairObj.num) {
+      case 'chair1':
+        this.chairs.first.push(chair);
+        break;
+
+      case 'chair2':
+        this.chairs.second.push(chair);
+        break;
+    }
+
+  };
+
+  Person.methods.removeChair = function(chairObj, orgId) {
+
+    var field = 'chairs.first';
+    switch(chairObj.num) {
+      case 'chair1':
+        this.chairs.first = _.filter(this.chairs.first, function(chair) {
+          var id = utils.isValidObjectId(chair.company.toString()) ? chair.company.toString() : chair.company.id.toString();
+          return id != orgId;
+        });
+        break;
+
+      case 'chair2':
+        field = 'chairs.second';
+        this.chairs.second = _.filter(this.chairs.second, function(chair) {
+          var id = utils.isValidObjectId(chair.company.toString()) ? chair.company.toString() : chair.company.id.toString();
+          return chair.company.id != orgId;
+        });
+        break;
+    }
+
+    if(chairObj.val && chairObj.val == "") {
+      this.previous.push({
+        field: field,
+        value: {
+          company: orgId
+        }
+      });
+    }
+
+  };
+
+  /************* ACCESS **********************/
+
+  Person.methods.funds = function() {
+    return getActiveFunds(this);
+  };
+
+  Person.methods.isSubscriber = function() {
+    return this.subscriptions && this.subscriptions.length >= 1;
+  };
+
+////////////
+
+  // search for people based on fields provided
+  // Data format, everything is optional
+  //{
+  //  emails: [],
+  //  phones: [],
+  //  name: {
+  //    first: '',
+  //    last: '',
+  //    full: ''
+  //  },
+  //  rawQuery: ''
+  //}
+  // first and last names are prioritized over full
+  // full, if used, is tokenized into first and last
+  // fuzzy searches within strings, e.g., searching for "Drew" will match "Andrew"
+  // non-fuzzy does a full-string match, e.g., "Andrew" will match "Andrew" but "Drew" will not
+  // both fuzzy and non are case-insensitive
+  // fuzzy only applies to name, not email or phone
+  // related people are removed from top-level results
+  Person.statics.search = function (data, options, cb) {
+
+    // validate input
+    if (!cb) throw new Error('cb is required');
+    if (!data || (!data.emails && !data.phones && !data.name)) return cb(null, []);
+
+    var self = this;
+    var query;
+
+    var buildQuery = function buildQuery(data, options) {
+
+      var cleanQuery = function cleanQuery(query) {
+
+        // "and" isn't used, so remove it
+        if (query['$and'].length == 0) {
+          delete query['$and'];
+        }
+
+        // "and" is only used for name, which is one more thing to "or" so move it to "or"
+        // note that changes may be needed if "and" is used for other things as well
+        else {
+          query['$or'].push({ '$and': query['$and'] });
+          delete query['$and'];
+        }
+
+        return query;
+
+      };
+
+      var getNicknames = function getNicknames(word, dictionary) {
+        var synonyms = dictionary[word.toLowerCase()];
+        if (!synonyms) return [word];
+        return synonyms;
+      };
+
+      var oneWordFullNameQuery = function oneWordFullNameQuery(data) {
+        var fullNameContainsSpace = data.name.full.indexOf(' ') >= 0;
+        var result = data.name.full.length >= 1 && fullNameContainsSpace == false && data.original.name.first.length == 0 && data.original.name.last.length == 0;
+        return result;
+      };
+
+      var prepareDictionary = function prepareDictionary() {
+
+        var dictionary = require('../dictionaries/nicknames.json');
+
+        var dict = {};
+
+        // Expand synonyms dictionary for caching
+        _.each(dictionary, function(synonyms, word) {
+          var key = word.toLowerCase();
+          dict[key] = [word].concat(synonyms);
+          // Add values as keys for back-matching
+          dict[key].forEach(function(synonym) {
+            var synonymKey = synonym.toLowerCase();
+            if (!dict[synonymKey]) dict[synonymKey] = [word];
+            dict[synonymKey] = _.uniq(dict[synonymKey].concat(dict[key]));
+          });
+        });
+
+        return dict;
+
+      };
+
+      // prepare query
+      var query = {};
+      query['$or'] = [];  // these will be added dynamically from data parameter
+      query['$and'] = []; // these will be added dynamically from data parameter
+      query['deleted'] = { $ne: true }; // always include this
+
+      var dictionary = prepareDictionary();
+      var nicknames = getNicknames(data.name.first, dictionary);
+      var firstEscaped = escapeStringRegexp(data.name.first);
+      var firstRegExp = options.fuzzy ? new RegExp(firstEscaped, 'i') : new RegExp('^' + firstEscaped + '$', 'i');
+      var lastEscaped = escapeStringRegexp(data.name.last);
+      var lastRegExp = options.fuzzy ? new RegExp(lastEscaped, 'i') : new RegExp('^' + lastEscaped + '$', 'i');
+      var key = options.andFirstLast && data.name.first && data.name.last  ? '$and' : '$or';
+
+      // if we only have one word, search both first and last
+      if (oneWordFullNameQuery(data)) {
+
+        query['$or'].push({ 'name.first': firstRegExp });
+        query['$or'].push({ 'name.last': firstRegExp });
+
+      }
+
+      // options say to "and", rather than "or", first and last names
+      else if (options.andFirstLast && data.name.first && data.name.last) {
+
+        _.each(nicknames, function(nickname) {
+          var escapedNickname = escapeStringRegexp(nickname);
+          var nicknameRegExp = options.fuzzy ? new RegExp(escapedNickname, 'i') : new RegExp('^' + escapedNickname + '$', 'i');
+          query['$or'].push({ 'name.first': nicknameRegExp, 'name.last': lastRegExp });
+        });
+
+      }
+      else {
+
+        // include first unless options say not to
+        if (data.name.first && options.orLastOnly == false) {
+
+          _.each(nicknames, function (nickname) {
+            var escapedNickname = escapeStringRegexp(nickname);
+            var nicknameRegExp = options.fuzzy ? new RegExp(escapedNickname, 'i') : new RegExp('^' + escapedNickname + '$', 'i');
+            query[key].push({'name.first': nicknameRegExp});
+          });
+
+        }
+
+        // always include last if it's provided
+        if (data.name.last) {
+          query[key].push({ 'name.last': lastRegExp });
+        }
+
+      }
+
+      // search alias as well
+      if (data.name.first || data.name.last) {
+        var fullName = escapeStringRegexp((data.name.first + ' ' + data.name.last).trim());
+        var aliasRegExp = options.fuzzy ? new RegExp(fullName, 'i') : new RegExp('^' + fullName + '$', 'i');
+        query['$or'].push({ 'aliases': aliasRegExp });
+      }
+
+      // conditionally include emails and phones
+      if (data.emails) query['$or'].push({'contact.email.email': { $in : data.emails }});
+      if (data.phones) query['$or'].push({'contact.phone.number': { $in : data.phones }});
+
+      query = cleanQuery(query);
+
+      return query;
+
+    };
+
+    var prepData = function prepData(data) {
+
+      // add raw query to email query if it is an email
+      var addIfEmail = function addIfEmail(data) {
+
+        if (validator.isEmail(data.rawQuery)) {
+          if (data.emails.indexOf(data.rawQuery) == -1) {
+            data.emails.push(data.rawQuery);
+          }
+        }
+
+        return data;
+
+      };
+
+      // add raw query to phone query if it is a phone
+      var addIfPhone = function addIfPhone(data) {
+
+        var pn = new PhoneNumber(data.rawQuery, 'US');
+
+        if (pn.isValid()) {
+          if (data.phones.indexOf(data.rawQuery) == -1) {
+            data.phones.push(data.rawQuery);
+          }
+        }
+
+        return data;
+
+      };
+
+      // remove name from data if it's actually an email
+      var removeIfEmail = function removeIfEmail(data) {
+
+        if (validator.isEmail(data.name.full)) data.name.full = '';
+        if (validator.isEmail(data.name.first)) data.name.first = '';
+        if (validator.isEmail(data.name.last)) data.name.last = '';
+
+        return data;
+
+      };
+
+      // remove name from data if it's actually a phone number
+      var removeIfPhone = function removeIfPhone(data) {
+
+        var pnFull = new PhoneNumber(data.name.full, 'US');
+        if (pnFull.isValid()) data.name.full = '';
+
+        var pnFirst = new PhoneNumber(data.name.first, 'US');
+        if (pnFirst.isValid()) data.name.first = '';
+
+        var pnLast = new PhoneNumber(data.name.last, 'US');
+        if (pnLast.isValid()) data.name.last = '';
+
+        return data;
+
+      };
+
+      // break full name into parts
+      var tokenizeName = function tokenizeName(data) {
+
+        var parts = [];
+
+        try { parts = data.name.full.toString().split(' '); }
+        catch (err) { return data; }
+
+        // LIMITATION: Doesn't handle 2+ word first names, i.e., Bobbi Sue is fucked
+
+        // if there is at least one part, use the first, but don't overwrite
+        if (parts.length >= 1 && !data.name.first) data.name.first = parts[0].trim();
+
+        // if there are at least two parts, join all but the first, but don't overwrite
+        if (parts.length >= 2 && !data.name.last) data.name.last = parts.slice(1).join(' ');
+
+        return data;
+
+      };
+
+      // save the original name
+      data.original =
+        data.original = {
+          name: {
+            first: data.name && data.name.first || '',
+            last: data.name && data.name.last || ''
+          }
+        };
+
+      // make sure each field exists, even if empty, so we don't have to constantly check
+      data.emails = data.emails || [];
+      data.phones = data.phones || [];
+      data.name = data.name || {};
+      data.name.first = data.name.first || '';
+      data.name.last = data.name.last || '';
+      data.name.full = data.name.full || '';
+      data.rawQuery = data.rawQuery || '';
+
+      data = addIfEmail(data);
+      data = removeIfEmail(data);
+      data = addIfPhone(data);
+      data = removeIfPhone(data);
+      data = tokenizeName(data);
+
+      return data;
+
+    };
+
+    // All entities are searched initially, including entities that are listed as related to other entities
+    // Remove related entities from top-level results so they only come up as related
+    var removeRelatedFromTopLevel = function(items) {
+
+      var getRelatedIds = function getRelatedIds(items) {
+
+        var result = [];
+
+        _.each(items, function(item) {
+          if (item.related.length >= 1) {
+            var ids = _.pluck(item.related, 'id');
+            result = result.concat(ids);
+          }
+        });
+
+        return _.uniq(result);
+
+      };
+
+      var relatedIds = getRelatedIds(items);
+      items = _.reject(items, function(item) {
+        return relatedIds.indexOf(item.id) >= 0;
+      });
+
+      return items;
+
+    };
+
+    var defaultOptions = {
+
+      // accept partial matches
+      fuzzy: true,
+
+      // use 'and' clause, rather than 'or', between first and last
+      // note this trumps orLastOnly
+      andFirstLast: false,
+
+      // when not 'anding' first and last, query on last name but not first
+      // note this is trumped by andFirstLast
+      orLastOnly: true,
+
+      removeRelatedFromTopLevel: true
+
+    };
+
+    // combine provided and default options
+    options = utils.setDefaults(options, defaultOptions);
+
+    // need to be admin or provide investor id
+    if (!options.admin && !options.investor) return cb(null, []);
+
+    data = prepData(data);
+
+    query = buildQuery(data, options);
+
+    self
+      .find(query)
+      .select('avatarUrl name title related')
+      .exec(function(err, people) {
+
+        if (err) return cb(err, null);
+        else if (!people) return cb(null, null);
+        else {
+
+          if (options.removeRelatedFromTopLevel) people = removeRelatedFromTopLevel(people);
+
+          people = _.sortBy(people, function(person) { return person.name.full; });
+
+          return cb(null, people);
+
+        }
+
+      });
+
+  };
+
+  Person.statics.findDupes = function(person, options, cb) {
+
+    if (!cb) throw new Error('cb is required');
+    if (!person) return cb(null, []);
+
+    var emails = [];
+    if (person.contact && person.contact.email) {
+      // pluck emails
+      emails = _.map(person.contact.email, function(email) {
+        return email.email;
+      });
+    }
+
+    var phones = [];
+    if (person.contact && person.contact.phone) {
+      // pluck and normalize phone numbers
+      phones = _.map(person.contact.phone, function(phone) {
+        return phoneFormatter.normalize(phone.number);
+      });
+    }
+
+    // Sometimes clients pass in something like { name: 'Jason Reynolds' } rather than { name: { first: 'Jason', last: 'Reynolds' } }
+    // Parse it out as a courtesy
+    if (!person.name.first && !person.name.last) {
+      var fullName = person.name;
+      person = {
+        name: {
+          first: fullName.split(" ")[0],
+          last: fullName.split(" ")[1]
+        }
+      };
+    }
+
+    // Require names that are at least two characters long
+    if (person.name.first.length < 2) person.name.first = '';
+    if (person.name.last.length < 2) person.name.last = '';
+
+    this.search({
+      emails: emails,
+      phones: phones,
+      name: person.name
+    }, options, function(err, people) {
+
+      if (err) return cb(err, null);
+      if (!people) return cb(null, null);
+
+      // exclude passed in person from results
+      people = _.reject(people, function(p) {
+        return p.id == person.id;
+      });
+
+      return cb(null, people);
+
+    });
+
+  };
+
+  Person.statics.stats = function (cb) {
+    this.collection.stats(cb);
+  };
+
+  Person.statics.getById = function (id, cb) {
+
+    this
+      .findById(id)
+      .populate('account')
+      .populate('chairs.first.company')
+      .populate('chairs.second.company')
+      .populate('notes')
+      .populate('related')
+      .populate('sources.person')
+      .exec(function (err, person) {
+
+        if (err) return cb(err, null);
+        else if (!person) return cb(null, null);
+
+        person.sources = _.sortBy(person.sources, function(source) {
+          return source.interactions.calendar + source.interactions.email;
+        }).reverse();
+
+        return cb(null, person);
+
+      });
+
+  };
+
+  Person.statics.getByIdCustomer = function (id, customer, cb) {
+
+    // this would speed it up
+    // still need a way to optionally return all though
+    //.findById(id, { 'calendarEventSummaries': { $slice: 5 } })
+
+    this
+      .findById(id)
+      .select('-previous')
+      .populate('calendarEventSummaries.attendees.external', 'avatarUrl name title')
+      .populate('calendarEventSummaries.attendees.internal', 'avatarUrl name title')
+      .populate('calendarEventSummaries.notes')
+      .populate('chairs.first.company', 'logoUrl name')
+      .populate('chairs.second.company', 'logoUrl name')
+      .populate('sources.person', 'avatarUrl name title')
+      .deepPopulate([
+        'notes.createdBy',
+        'calendarEventSummaries.notes.createdBy'
+      ], {
+        populate: {
+          'notes.createdBy': {select: 'avatarUrl name'},
+          'calendarEventSummaries.notes.createdBy': { select: 'avatarUrl name' }
+        }
+      })
+      .exec(function (err, person) {
+
+        if (err) return cb(err, null);
+        else if (!person) return cb(null, null);
+
+        person.sources = _.sortBy(person.sources, function(source) {
+          return source.interactions.calendar + source.interactions.email;
+        }).reverse();
+
+        // note this gets filtered by customer in post init hook
+        // sort descending, i.e., reverse chronologically
+        person.calendarEventSummaries = _.sortBy(person.calendarEventSummaries, function(summary) {
+          return summary.startTime;
+        }).reverse();
+
+        return cb(null, person);
+
+      });
+
+  };
+
+  Person.statics.getByIdNoPopulate = function (id, cb) {
+
+    this
+      .findById(id)
+      .exec(cb);
+
+  };
+
+  Person.statics.getByIds = function (ids, cb) {
+    this
+      .find({ '_id': { $in : ids }, 'deleted': {$ne: true} })
+      .exec(cb);
+  };
+
+  // Retrieve any person matching an email in the emails array parameter
+  Person.statics.findByEmails = function (emails, cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+
+    this
+      .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
+      .select('name avatarUrl')
+      .exec(function (err, people) {
+        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
+      });
+
+  };
+
+  // Retrieve any person matching an email in the emails array parameter
+  Person.statics.findByEmailsSkinny = function (emails, cb) {
+    this
+      .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
+      .exec(cb);
+  };
+
+  // TODO - make dynamic
+  Person.statics.getPartners = function (cb) {
+
+    var partnerEmails = [
+      'john@ffvc.com',
+      'adam@ffvc.com',
+      'alex@ffvc.com',
+      'david@ffvc.com',
+      'michael@ffvc.com',
+      'ryan@ffvc.com',
+      'herb@ffvc.com',
+      'paul@ffvc.com'
+    ];
+
+    this
+      .find({ 'contact.email.email': { $in: partnerEmails }, 'deleted': { $ne: true } } )
+      .populate('account boards.company chairs.first.company chairs.second.company')
+      .exec(cb);
+
+  };
+
+  Person.statics.findByProviderEventId = function (id, cb) {
+    this
+      .find({ 'calendarEventSummaries.providerEventId': id })
+      .exec(cb);
+  };
+
+  Person.statics.findBySlug = function (slug, cb) {
+    this
+      .find({ slug: new RegExp(slug, 'i'), 'deleted': {$ne: true} })
+      .exec(cb);
+  };
+
+  Person.statics.findBySlugs = function (slugs, cb) {
+    this
+      .find({ 'slug': { $in : slugs }, 'deleted': {$ne: true} })
+      .exec(cb);
+  };
+
+  Person.statics.findByUniqueInfo = function (email, cb) {
+
+    // useful for not inserting dupes
+    // todo: expand this to check other fields
+
+    this.findOne({
+      $or: [
+        { 'contact.email': { $elemMatch: {'email': crypto.encrypt(email)} }},
+        { 'contact.email': { $elemMatch: {'email': email} }}
+      ]})
+      .populate('account boards.company leadership.company chairs.first.company chairs.second.company')
+      .exec(cb);
+
+  };
+
+  Person.statics.listAllPeople = function (cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+
+    var query = this.find({'deleted': {$ne: true}});
+    query.populate('account chairs.first.company chairs.second.company');
+    query.exec(function (err, people) {
+      cb(err, _.sortBy(people, function(person) { return person.name.full; }));
+    });
+
+  };
+
+  Person.statics.listMostRecentPeople = function (cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+
+    this
+      .find({'deleted': {$ne: true}})
+      .sort({'_id': 1})
+      .limit(100)
+      .exec(function (err, people) {
+        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
+      });
+
+  };
+
+  Person.statics.listPage = function (skip, cb) {
+
+    this
+      .find({'deleted': {$ne: true}})
+      .sort({'name.first':1, 'name.last':1})
+      .skip(skip)
+      .limit(100)
+      .exec(cb);
+
+  };
+
+  Person.statics.listAllPeopleNoPop = function (cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+
+    var query = this.find({'deleted': {$ne: true}});
+    query.exec(function (err, people) {
+      cb(err, _.sortBy(people, function(person) { return person.name.full; }));
+    });
+
+  };
+
+  Person.statics.listAllUnverifiedPeople = function (cb) {
+
+    this
+      .find({'status.verified': false, 'deleted': {$ne: true}})
+      .sort({'_id': 1})
+      .limit(100)
+      .exec(function (err, people) {
+        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
+      });
+
+  };
+
+  Person.statics.listAllFlaggedPeople = function (cb) {
+
+    this
+      .find({'flagged.resolved': false, 'flagged.text': { $ne: '' }, 'deleted': {$ne: true}})
+      .exec(function (err, people) {
+        people = _.sortBy(people, function(person){
+          var timestamp = new Date(person.flagged.on);
+          timestamp = timestamp.getTime();
+          return timestamp;
+        });
+        people = people.reverse();
+
+        cb(err, people);
+      });
+
+  };
+
+  Person.statics.listAllPeopleWithoutAccounts = function (cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+
+    this
+      .find({account: {$exists: false}, 'deleted': {$ne: true}})
+      .exec(function (err, people) {
+        cb(err, _.sortBy(people, function(person) { return person.name.full; }));
+      });
+
+  };
+
+  Person.statics.listForSubscription = function (subscriptionId, cb) {
+
+    this
+      .find({ 'subscriptions.id': subscriptionId, 'deleted': {$ne: true}})
+      .exec(function(err, people) {
+        cb(err, people);
+      });
+
+  };
+
+  Person.statics.addChair = function(personId, chairPos, companyId, cb) {
+
+    this.findById(personId).exec(function(err, person) {
+
+      var chairObj = {
+        company: companyId,
+        start: ''
+      };
+
+      switch(chairPos) {
+        case 'first':
+          person.chairs.first.push(chairObj);
+          break;
+
+        case 'second':
+          person.chairs.second.push(chairObj);
+          break;
+      }
+
+      person.save(cb);
+
+    });
+
+  };
+
+  //same function for flag resolved and unresolved... all based on true|false resolved arg
+  Person.statics.flag = function(personId, resolved, text, username, cb) {
+
+    this.findById(personId).exec(function(err, person) {
+
+      if (!person) return cb(new Error('person not found'), null);
+
+      person.flagged.resolved = resolved;
+      person.flagged.text = text;
+      person.flagged.by = username;
+      person.flagged.on = Date.now();
+
+      person.save(cb);
+
+    });
+
+  };
+
+  Person.statics.setCustomerCompanyIds = function(ids) {
+    customerCompanyIds = ids;
+  };
+
+  Person.statics.upsert = function(currentPerson, username, cb) {
+
+    if (!currentPerson) { return cb(new Error('Current Person is required'), null); }
+    if (!username) { return cb(new Error('Username is required'), null); }
+
+    currentPerson.entered = {
+      by: username,
+      on: new Date()
+    };
+
+    currentPerson.save(cb);
+
+  };
+
+  Person.statics.addNote = function(personId, creatorPersonId, text, cb) {
+
+    Note.createForModel({
+      createdBy: creatorPersonId,
+      text: text
+    }, this, personId, cb);
+
+  };
+
+  Person.statics.deleteNote = function(noteId, cb) {
+
+    // Delete the note itself along with any references on people
+
+    var self = this;
+
+    var removePersonNoteReferences = function removePersonNoteReferences(callback) {
+      self.update({}, {
+        $pull: { 'notes' : [noteId] }
+      }, callback);
+    };
+
+    var removeEventNoteReferences = function removeEventNoteReferences(callback) {
+      self.update({
+        'calendarEventSummaries.notes': noteId
+      }, {
+        $pull: { 'calendarEventSummaries.$.notes' : [noteId] }
+      }, callback);
+    };
+
+    async.series([
+      Note.delete.bind(Note, noteId),
+      removePersonNoteReferences,
+      removeEventNoteReferences
+    ], function(err, results) {
+      return cb(err, null);
+    });
+
+  };
+
+///////////////
+
+  // Person.pre('save', function(next) {
+  //   var self = this;
+  //   var PersonHistory = mongoose.model('PersonHistory');
+  //   var snapshot = new PersonHistory();
+  //   snapshot.create(self, 'jason', function(err, result) {
+  //     if (err) {} // todo: alert admin to fix; ok to proceed;
+  //     return next();
+  //   });
+  // });
+
+  Person.post('remove', function(doc) {
+    // Account.person
+    // Investor.people
+    // Investor.formerPeople
+    // LimitedPartner.person
+    // Organization.people.person
+    // Person.merged
+    // Person.related
+    // Person.calendarEventSummaries.attendees.internal
+    // Person.calendarEventSummaries.attendees.external
+    // PortfolioCompany.chairs.first
+    // PortfolioCompany.chairs.second
+    // PortfolioCompany.boards
+    // PortfolioCompany.leadership.person
+    // PortfolioCompany.people.person
+    // PortfolioCompany.formerPeople
+  });
+
+  var protectCustomerData = function(context) {
+
+    var CUSTOMER_ID = config.CUSTOMER_ID;
+
+    var protectCalendarEventData = function protectCalendarEventData(person) {
+
+      if (CUSTOMER_ID == 'GLOBAL_PROCESS') return;
+
+      person.calendarEventSummaries = _.reject(person.calendarEventSummaries, function(event) {
+        return event.totemCustomerId != CUSTOMER_ID;
+      });
+
+    };
+
+    var protectSources = function protectSources(person) {
+
+      if (CUSTOMER_ID == 'GLOBAL_PROCESS') return;
+
+      person.sources = _.reject(person.sources, function(source) {
+        var customerId = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
+        return customerId.toString() != CUSTOMER_ID.toString();
+      });
+
+    };
+
+    protectCalendarEventData(context);
+    protectSources(context);
+
+  };
+
+  Person.pre('save', function(next) {
+
+    var self = this;
+
+    // Reset counters so we can calc from scratch
+    _.each(self.sources, function(source) {
+      source.interactions.calendar = 0;
+    });
+
+    _.each(self.calendarEventSummaries, function(ces) {
+
+      var customerId = ces.totemCustomerId;
+
+      // Each attendee from the customer is a source
+      _.each(ces.attendees.internal, function(attendee) {
+
+        var aid = mongoose.Types.ObjectId.isValid(attendee) ? attendee : attendee._id;
+
+        // Check if this attendee has already been added as a source
+        var match = _.find(self.sources, function(source) {
+          // It's a match if both person and customer ids are a match
+          var pid = mongoose.Types.ObjectId.isValid(source.person) ? source.person : source.person._id;
+          var cid = mongoose.Types.ObjectId.isValid(source.customer) ? source.customer : source.customer._id;
+          return pid.toString() == aid.toString() && cid.toString() == customerId.toString();
+        });
+
+        // If source already added, increment counter
+        if (match) { match.interactions.calendar += 1; }
+
+        // Otherwise add the source
+        else {
+          self.sources.push({
+            person: aid,
+            customer: customerId,
+            interactions: { calendar: 1 }
+          });
+        }
+
+      });
+
+    });
+
+    next();
+
+  });
+
+  Person.post('init', function() {
+    protectCustomerData(this);
+  });
+
+  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  Person.plugin(deepPopulate);
+
+  Person.set('autoIndex', true);
+  Person.on('index', function(err) { console.log('error building person indexes: ' + err); });
+
+  Person.set('toJSON', { virtuals: true });
+
+  mongoose.model('Person', Person);
+
+};