@dhyasama/totem-merge 6.0.1

package/lib/people.js

@@ -0,0 +1,739 @@
+"use strict";
+
+let async = require('async');
+let _ = require('underscore');
+let helpers = require('./helpers');
+let mongoose = require('mongoose');
+let ObjectId = mongoose.Types.ObjectId;
+
+var merge = function merge(context, target, source, mergedBy, customerId, cb) {
+
+  console.log('Merging people...');
+
+  // validate parameters
+  if (!context) return cb(new Error('context is required'), null);
+  if (!target) return cb(new Error('target is required'), null);
+  if (!source) return cb(new Error('source is required'), null);
+  if (!mergedBy) return cb(new Error('mergedBy is required'), null);
+  if (!cb) throw new Error('cb is required');
+
+  var savePerson = function(person, username, callback) {
+
+    console.log('Saving target person...');
+    console.log('  ID:', person._id.toString());
+
+    context.Person.upsert(person, username, function(err, result) {
+      return callback(err, result);
+    });
+
+  };
+
+  if (context.flagOnly) {
+
+    var url = 'https://admin.totemvc.com/people/' + source.id;
+    var text = 'This person should be merged with ' + url;
+
+    context.Person.addFlag(target._id, target._id, text, customerId, function(err, result) {
+      if (err) return cb(err, null);
+      return cb(null, result);
+    });
+
+  }
+  else {
+
+    // mergedBy can be either an account or a username
+    var username = mergedBy.username ? mergedBy.username : mergedBy;
+
+    async.series([
+
+      // Create a snapshot of the target
+      helpers.createSnapshot.bind(null, context, 'Person', target, username),
+
+      // Create a snapshot of the source
+      helpers.createSnapshot.bind(null, context, 'Person', source, username),
+
+      // Merge the source into the target
+      mergeSourceIntoTarget.bind(null, target, source),
+
+      // Delete the source
+      // Do this prior to saving merged target in order to avoid unique key issues
+      helpers.removeEntity.bind(null, context, source),
+
+      // Save the updated target
+      savePerson.bind(null, target, username),
+
+      // Change source references to target
+      updateReferences.bind(null, context, target, source, mergedBy)
+
+    ], function(err, results) {
+
+      if (err) return cb(err, null);
+
+      // result from savePerson
+      var updatedTarget = results[4];
+
+      // return updated target
+      return cb(null, updatedTarget);
+
+    });
+
+  }
+
+};
+
+var mergeSourceIntoTarget = function mergeEntities(target, source, cb) {
+
+  console.log('Merging source into target...');
+
+  var doNotMergeKeys = [
+    'merged',
+    'deleted',
+    'entered',
+    '__v',
+    'status',
+    'lps',
+    'subscriptions',
+    'account',
+    'sources'
+  ];
+
+  var mergeSources = function mergeSources(target, source) {
+
+    // Note interaction counts are not combined here but will be updated on next calendar pull
+
+    var targetSources = target.sources || [];
+    var sourceSources = source.sources || [];
+
+    _.each(sourceSources, function(sourceSource) {
+
+      var match = _.find(targetSources, function(targetSource) {
+        return targetSource.customer.toString() === sourceSource.customer.toString() && targetSource.person.toString() === sourceSource.person.toString();
+      });
+
+      if (!match) { targetSources.push(sourceSource); }
+
+    });
+
+    return targetSources;
+
+  };
+
+  helpers.mergeObjects(target, source, doNotMergeKeys);
+
+  target.sources = mergeSources(target, source);
+
+  // keep a list of copied people
+  target.addMerged(source.id);
+
+  // add copied person name as an alias if it's different from source name
+  if (target.name.full.toLowerCase() != source.name.full.toLowerCase()) {
+    target.aliases = target.aliases.concat([source.name.full]);
+    target.aliases = _.uniq(target.aliases);
+  }
+
+  // mark as entered by system
+  target.entered = {
+    by: 'ff-merge',
+    on: new Date()
+  };
+
+  return cb(null, target);
+
+};
+
+// Flow control for updating references
+// Takes us through updating each entity type
+var updateReferences = function updateReferences(context, target, source, mergedBy, cb) {
+
+  console.log('Updating references...');
+
+  // validate parameters
+  if (!context) return cb(new Error('context is required'), null);
+  if (!target) return cb(new Error('target is required'), null);
+  if (!source) return cb(new Error('source is required'), null);
+  if (!cb) throw new Error('cb is required');
+
+  var oldPersonId = ObjectId(source.id);
+  var newPersonId = ObjectId(target.id);
+
+  console.log('  Target:', newPersonId.toString());
+  console.log('  Source:', oldPersonId.toString());
+
+  // mergedBy can be either an account or a username
+  var username = mergedBy.username ? mergedBy.username : mergedBy;
+
+  // Do not update cap tables or rounds as these are complicated
+  // and get cleaned and updated on each pull anyway
+
+  async.parallel([
+
+    updateDeals.bind(context, newPersonId, oldPersonId, mergedBy),
+
+    updateDocuments.bind(context, newPersonId, oldPersonId, null),
+
+    updateFlags.bind(context, newPersonId, oldPersonId, username),
+
+    updateInteractions.bind(context, newPersonId, oldPersonId, username),
+
+    updateLimitedPartners.bind(context, newPersonId, oldPersonId, mergedBy),
+
+    updateLists.bind(context, newPersonId, oldPersonId, null),
+
+    updateMessages.bind(context, newPersonId, oldPersonId, null),
+
+    updateNotes.bind(context, newPersonId, oldPersonId, username),
+
+    updateOrganizations.bind(context, newPersonId, oldPersonId, username),
+
+    updatePeople.bind(context, newPersonId, oldPersonId, username)
+
+  ], cb);
+
+};
+
+var updateDeals = function updateDeals(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating deals...');
+
+  var self = this;
+
+  // Get all deals for this person
+  self.Deal.collection.find({ $or: [{ 'source.person': oldPersonId }, { 'referrer.person': oldPersonId }]}).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      var setObj = {};
+
+      if (item.source && item.source.person && item.source.person.toString() === oldPersonId.toString()) { setObj.source = { person: newPersonId }; }
+      if (item.referrer && item.referrer.person && item.referrer.person.toString() === oldPersonId.toString()) { setObj.referrer = { person: newPersonId }; }
+
+      tasks.push({
+        id: item._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' deal references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Deal.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateDocuments = function updateDocuments(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating docs...');
+
+  var self = this;
+
+  // Get all documents for this person
+  self.Document.collection.find({ $or: [{ 'source.person': oldPersonId }, { 'referrer.person': oldPersonId }]}).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      var setObj = {};
+
+      if (item.source && item.source.person && item.source.person.toString() === oldPersonId.toString()) { setObj.source = { person: newPersonId }; }
+      if (item.referrer && item.referrer.person && item.referrer.person.toString() === oldPersonId.toString()) { setObj.referrer = { person: newPersonId }; }
+
+      tasks.push({
+        id: item._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' doc references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Document.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateFlags = function updateFlags(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating flags...');
+
+  var self = this;
+
+  // Get all flags for this person
+  self.Flag.collection.find({ 'createdBy': oldPersonId }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      var setObj = {};
+
+      if (item.createdBy.toString() === oldPersonId.toString()) { setObj.createdBy = newPersonId; }
+
+      tasks.push({
+        id: item._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' flag references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Flag.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateInteractions = function updateInteractions(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating interactions...');
+
+  var self = this;
+
+  // Get all interactions for this person
+  self.Interaction.collection.find({ $or: [{ 'attendees.external': oldPersonId }, { 'attendees.internal': oldPersonId }] }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      item.attendees.internal = _.map(item.attendees.internal, function(attendee) {
+        if (attendee.toString() === oldPersonId.toString()) { attendee = newPersonId; }
+        return attendee;
+      });
+
+      item.attendees.external = _.map(item.attendees.external, function(attendee) {
+        if (attendee.toString() === oldPersonId.toString()) { attendee = newPersonId; }
+        return attendee;
+      });
+
+      tasks.push({
+        id: item._id,
+        update: { $set: {
+            'attendees.internal': item.attendees.internal,
+            'attendees.external': item.attendees.external
+          }
+        }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' interaction references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Interaction.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateLimitedPartners = function updateLimitedPartners(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating lps...');
+
+  var self = this;
+
+  // Get all lps for this person
+  self.LimitedPartner.collection.find({ 'people': oldPersonId }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      item.people = _.map(item.people, function(person) {
+        if (person.toString() === oldPersonId.toString()) { person = newPersonId; }
+        return person;
+      });
+
+      tasks.push({
+        id: item._id,
+        update: { $set: {
+            'people': item.people
+          }
+        }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' lp references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.LimitedPartner.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateLists = function updateLists(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating lists...');
+
+  var self = this;
+
+  // Get all lists for this person
+  self.List.collection.find({ $or: [{ 'people': oldPersonId }, { 'createdBy': oldPersonId }] }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      var setObj = {};
+
+      if (item.createdBy.toString() === oldPersonId.toString()) { setObj.createdBy = newPersonId; }
+
+      setObj.people = _.map(item.people, function(person) {
+        if (person.toString() === oldPersonId.toString()) { person = newPersonId; }
+        return person;
+      });
+
+      tasks.push({
+        id: item._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' list references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.List.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateMessages = function updateMessages(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating messages...');
+
+  var self = this;
+
+  // Get all messages for this person
+  self.Message.collection.find({ $or: [{ 'recipients.external': oldPersonId }, { 'recipients.internal': oldPersonId }] }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      item.recipients.internal = _.map(item.recipients.internal, function(recipient) {
+        if (recipient.toString() === oldPersonId.toString()) { recipient = newPersonId; }
+        return recipient;
+      });
+
+      item.recipients.external = _.map(item.recipients.external, function(recipient) {
+        if (recipient.toString() === oldPersonId.toString()) { recipient = newPersonId; }
+        return recipient;
+      });
+
+      tasks.push({
+        id: item._id,
+        update: { $set: {
+            'recipients.internal': item.recipients.internal,
+            'recipients.external': item.recipients.external
+          }
+        }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' message references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Message.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateNotes = function updateNotes(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating notes...');
+
+  var self = this;
+
+  // Get all notes for this person
+  self.Note.collection.find({ 'createdBy': oldPersonId }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      var setObj = {};
+
+      if (item.createdBy.toString() === oldPersonId.toString()) { setObj.createdBy = newPersonId; }
+
+      tasks.push({
+        id: item._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' note references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Note.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updateOrganizations = function updateOrganizations(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating orgs...');
+
+  var self = this;
+
+  // Get all orgs for this person
+  self.Organization.collection.find({ $or: [{ 'people.person': oldPersonId }, { 'chair.first': oldPersonId }, { 'chair.second': oldPersonId }] }).toArray(function(err, orgs) {
+
+    if (err) return cb(err, null);
+    else if (!orgs || orgs.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    var checkIfBothPeopleAtOrg = function checkIfBothPeopleAtOrg(org) {
+
+      // if we blindly mapped the old person to the new person when they are both at the same org, then we'd end up
+      // with something like this:
+      //
+      // [ {
+      //    person: 5cacc6238d38a6f68bf53c95,
+      //    board: 'none',
+      //    public: true,
+      //    leader: false,
+      //    current: true,
+      //    title: 'CEO'
+      //   },
+      //   {
+      //    person: 5cacc6238d38a6f68bf53c95,
+      //    board: 'none',
+      //    public: true,
+      //    leader: false,
+      //    current: true,
+      //    title: 'CTO'
+      //   }
+      // ]
+      //
+      // and be unable to determine which data to keep. We still can't know for sure, but let's default to keeping the
+      // target/new person's data. We do that by removing the source/old person here and then map the target/new person id.
+
+      var oldPerson = _.find(org.people, function(person) { return person.person.toString() === oldPersonId.toString(); });
+      var newPerson = _.find(org.people, function(person) { return person.person.toString() === newPersonId.toString(); });
+
+      // Both people are at this org
+      if (oldPerson && newPerson) {
+        org.people = _.reject(org.people, function(person) {
+          return person.person.toString() === oldPersonId.toString();
+        });
+      }
+
+    };
+
+    _.each(orgs, function(org) {
+
+      var setObj = {};
+
+      // keep the target info and remove the source if at the same org
+      // note this must be done before mapping the old id to the new id
+      checkIfBothPeopleAtOrg(org);
+
+      setObj.people = _.map(org.people, function(person) {
+        if (person.person.toString() === oldPersonId.toString()) { person.person = newPersonId; }
+        return person;
+      });
+
+      setObj.chairs = _.map(org.chairs, function(chair) {
+        if (chair.first && chair.first.toString() === oldPersonId.toString()) { chair.first = newPersonId; }
+        if (chair.second && chair.second.toString() === oldPersonId.toString()) { chair.second = newPersonId; }
+        return chair;
+      });
+
+      tasks.push({
+        id: org._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' org references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Organization.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+var updatePeople = function updatePeople(newPersonId, oldPersonId, user, cb) {
+
+  console.log('  Updating people...');
+
+  var self = this;
+
+  // Get all orgs for this person
+  self.Organization.collection.find({ 'related': oldPersonId }).toArray(function(err, items) {
+
+    if (err) return cb(err, null);
+    else if (!items || items.length === 0) return cb(null, []);
+
+    var tasks = [];
+    var updated = [];
+
+    _.each(items, function(item) {
+
+      var setObj = {};
+
+      setObj.related = _.map(item.related, function(person) {
+        if (person.toString() === oldPersonId.toString()) { person = newPersonId; }
+        return person;
+      });
+
+      tasks.push({
+        id: item._id,
+        update: { $set: setObj }
+      });
+
+    });
+
+    console.log('    Found ' + tasks.length + ' person references to update');
+
+    var queue = async.queue(function(task, callback) {
+      self.Organization.modifyById(task.id, task.update, function(err, result) {
+        if (err) { return callback(err, null); }
+        else if (result) { updated.push(result); }
+        return callback(null, result);
+      });
+    }, 8);
+
+    queue.drain = function() { return cb(null, updated); };
+
+    queue.push(tasks);
+
+  });
+
+};
+
+module.exports.merge = merge;