@dhyasama/totem-models 12.3.0 → 12.4.0

package/lib/Person.js

@@ -288,119 +288,127 @@ module.exports = function(mongoose, config) {
     Note.createForModel(this, personId, note, cb);
   };
 
-  Person.statics.deleteNote = function(noteId, customerId, cb) {
+  Person.statics.deleteNote = async function(noteId, customerId, cb) {
 
     // Delete the note itself along with any references on people
 
-    const self = this;
-
-    let removePersonNoteReferences = function removePersonNoteReferences(callback) {
-      self.updateMany({}, {
+    try {
+      await Note.delete(noteId, customerId);
+      await this.updateMany({}, {
         $pull: { 'notes' : [noteId] }
-      }).then(function(result) { callback(null, result); }).catch(function(err) { callback(err); });
-    };
-
-    async.series([
-      Note.delete.bind(Note, noteId, customerId),
-      removePersonNoteReferences
-    ], function(err, results) {
+      });
+      return cb(null, null);
+    } catch(err) {
       return cb(err, null);
-    });
+    }
 
   };
 
   // Retrieve any person matching an email in the emails array parameter
-  Person.statics.findByEmails = function (emails, cb) {
-
-    this
-      .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
-      .select('name avatarUrl title doNotDisplay contact')
-      .sort('name.full')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+  Person.statics.findByEmails = async function (emails, cb) {
+
+    try {
+      let query = this
+        .find({ 'contact.email.email': { $in : emails }, 'deleted': {$ne: true}})
+        .select('name avatarUrl title doNotDisplay contact')
+        .sort('name.full');
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.findBySlug = function (slug, cb) {
-
-    const self = this;
+  Person.statics.findBySlug = async function (slug, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!slug) { return cb(new Error('slug must be provided'), null); }
 
-    self
-      .findOne({ slug: new RegExp(slug, 'i'), 'deleted': { $ne: true } })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .findOne({ slug: new RegExp(slug, 'i'), 'deleted': { $ne: true } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.findBySlugs = function findBySlugs(slugs, cb) {
-
-    const self = this;
+  Person.statics.findBySlugs = async function findBySlugs(slugs, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!slugs) { return cb(new Error('slug must be provided'), null); }
 
-    self.find({ 'slug': { $in : slugs } }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.find({ 'slug': { $in : slugs } });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.findBySocial = function findBySocial(value, cb) {
+  Person.statics.findBySocial = async function findBySocial(value, cb) {
 
     // Extract stand-alone username and append it to our standardized domains
 
-    const self = this;
-
     if (!value) { return cb(new Error('value must be provided'), null); }
 
     let username = utilities.getUsernameFromUrl(value);
 
     if (!username) { return cb(null, []); }
 
-    self
-      .find({ $or:
-          [
-            { 'social.facebook': new RegExp('facebook.com/' + username + '$/?', 'i') },
-            { 'social.linkedin': new RegExp('linkedin.com/in/' + username + '\/?$', 'i') },
-            { 'social.twitter': new RegExp('twitter.com/' + username + '/?$', 'i') }
-          ],
-        'deleted': { $ne: true }
-      })
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .find({ $or:
+            [
+              { 'social.facebook': new RegExp('facebook.com/' + username + '$/?', 'i') },
+              { 'social.linkedin': new RegExp('linkedin.com/in/' + username + '\/?$', 'i') },
+              { 'social.twitter': new RegExp('twitter.com/' + username + '/?$', 'i') }
+            ],
+          'deleted': { $ne: true }
+        });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.findBySocials = function findBySocials(values, cb) {
+  Person.statics.findBySocials = async function findBySocials(values, cb) {
 
     // Extract usernames and append it to our standardized domains
 
-    const self = this;
-
     if (!cb) { throw new Error('cb is required'); }
     if (!values) { return cb(new Error('values is required'), null); }
 
-    let facebookRegexes = _.map(values, function(value) { return new RegExp('facebook.com/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
-    let linkedinRegexes = _.map(values, function(value) { return new RegExp('linkedin.com/in/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
-    let twitterRegexes = _.map(values, function(value) { return new RegExp('twitter.com/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
-    let crunchbaseRegexes = _.map(values, function(value) { return new RegExp('crunchbase.com/person/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
-    let pitchbookRegexes = _.map(values, function(value) { return new RegExp('pitchbook.com/profiles/person/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
-
-    self
-      .find({ $or:
-          [
-            { 'social.facebook': {$in: facebookRegexes }},
-            { 'social.linkedin': {$in: linkedinRegexes }},
-            { 'social.twitter': {$in: twitterRegexes }},
-            { 'crunchbase.url': {$in: crunchbaseRegexes }},
-            { 'pitchbook.url': {$in: pitchbookRegexes }},
-          ],
-        'deleted': { $ne: true }
-      }).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      let facebookRegexes = _.map(values, function(value) { return new RegExp('facebook.com/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
+      let linkedinRegexes = _.map(values, function(value) { return new RegExp('linkedin.com/in/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
+      let twitterRegexes = _.map(values, function(value) { return new RegExp('twitter.com/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
+      let crunchbaseRegexes = _.map(values, function(value) { return new RegExp('crunchbase.com/person/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
+      let pitchbookRegexes = _.map(values, function(value) { return new RegExp('pitchbook.com/profiles/person/' + utilities.getUsernameFromUrl(value) + '\/?$', 'i') });
+
+      const result = await this
+        .find({ $or:
+            [
+              { 'social.facebook': {$in: facebookRegexes }},
+              { 'social.linkedin': {$in: linkedinRegexes }},
+              { 'social.twitter': {$in: twitterRegexes }},
+              { 'crunchbase.url': {$in: crunchbaseRegexes }},
+              { 'pitchbook.url': {$in: pitchbookRegexes }},
+            ],
+          'deleted': { $ne: true }
+        });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.getById = function (id, options, cb) {
-
-    const self = this;
+  Person.statics.getById = async function (id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -414,33 +422,34 @@ module.exports = function(mongoose, config) {
       if (!mongoose.Types.ObjectId.isValid(options.CUSTOMER_ID)) { return cb(new Error('options.CUSTOMER_ID is not a valid ObjectId'), null); }
     }
 
-    self
-      .findById(id)
-      .select('-previous')
-      .populate('related')
-      .populate('sources.person', 'avatarUrl name title doNotDisplay')
-      .populate('documents')
-      .exec().then(function(person) {
+    try {
+      let query = this
+        .findById(id)
+        .select('-previous')
+        .populate('related')
+        .populate('sources.person', 'avatarUrl name title doNotDisplay')
+        .populate('documents');
+      const person = await query;
       if (!person) return cb(null, null);
 
-        if (!options.isWorkerProcess) { person = helpers.cleanPerson(person, options.CUSTOMER_ID); }
+      let cleanedPerson = person;
+      if (!options.isWorkerProcess) { cleanedPerson = helpers.cleanPerson(person, options.CUSTOMER_ID); }
 
-        person.sources = _.sortBy(person.sources, function(source) {
-          return source.interactions.calendar + source.interactions.email;
-        }).reverse();
+      cleanedPerson.sources = _.sortBy(cleanedPerson.sources, function(source) {
+        return source.interactions.calendar + source.interactions.email;
+      }).reverse();
 
-        return cb(null, person);
-
-      }).catch(function(err) { cb(err); });
+      return cb(null, cleanedPerson);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.getByIdNoPopulate = function (id, options, cb) {
+  Person.statics.getByIdNoPopulate = async function (id, options, cb) {
 
     // only for worker
 
-    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); }
@@ -450,13 +459,16 @@ module.exports = function(mongoose, config) {
 
     if (!options.isWorkerProcess) { return cb(null, null); }
 
-    self.findById(id).exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this.findById(id);
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.getByIds = function (ids, options, cb) {
-
-    const self = this;
+  Person.statics.getByIds = async function (ids, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!ids) { return cb(new Error('ids is required'), null); }
@@ -464,33 +476,36 @@ module.exports = function(mongoose, config) {
     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); }
 
-    self
-      .find({ '_id': { $in : ids }, 'deleted': {$ne: true} })
-      .exec().then(function(people) {
+    try {
+      const people = await this
+        .find({ '_id': { $in : ids }, 'deleted': {$ne: true} });
       if (!people) { return cb(null, []); }
 
-        people = _.map(people, function(person) {
-          return helpers.cleanPerson(person, options.CUSTOMER_ID);
-        });
-
-        return cb(null, people);
+      const cleaned = _.map(people, function(person) {
+        return helpers.cleanPerson(person, options.CUSTOMER_ID);
+      });
 
-      }).catch(function(err) { cb(err); });
+      return cb(null, cleaned);
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Person.statics.getList = function getList(cb) {
+  Person.statics.getList = async function getList(cb) {
 
-    var self = this;
-
-    self
-      .find({'deleted': {$ne: true}})
-      .select('name contact.email')
-      .lean()
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .find({'deleted': {$ne: true}})
+        .select('name contact.email')
+        .lean();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.getNotes = function getNotes(personId, options, cb) {
+  Person.statics.getNotes = async function getNotes(personId, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!personId) { return cb(new Error('personId is required'), null); }
@@ -499,22 +514,26 @@ module.exports = function(mongoose, config) {
     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); }
 
-    const self = this;
-    let query = self.findById(personId);
+    try {
+      let query = this.findById(personId);
 
-    query.select('notes');
-    query.populate({
-      path: 'notes',
-      match: { customer: options.CUSTOMER_ID },
-      populate: { path: 'createdBy', select: 'name avatarUrl title' }
-    });
-    query.sort({'createdOn':-1});
+      query.select('notes');
+      query.populate({
+        path: 'notes',
+        match: { customer: options.CUSTOMER_ID },
+        populate: { path: 'createdBy', select: 'name avatarUrl title' }
+      });
+      query.sort({'createdOn':-1});
 
-    query.exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await query;
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.getSources = function (id, options, cb) {
+  Person.statics.getSources = async function (id, options, cb) {
 
     if (!cb) { throw new Error('cb is required'); }
     if (!id) { return cb(new Error('id is required'), null); }
@@ -523,55 +542,53 @@ module.exports = function(mongoose, config) {
     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); }
 
-    const self = this;
-
-    // get the person
-    let query = self.findById(id);
+    try {
+      // get the person
+      let query = this.findById(id);
 
-    query.populate('sources.person');
+      query.populate('sources.person');
 
-    query.exec().then(function(person) {
+      const person = await query;
       if (!person) { return cb(null, null); }
 
       // get the customer's org
-      Organization.findById(options.CUSTOMER_ID).then(function(customer) {
-        if (!customer) { return cb(null, null); }
+      const customer = await Organization.findById(options.CUSTOMER_ID);
+      if (!customer) { return cb(null, null); }
 
-        let current = [];
-        let past = [];
-        let all = [];
+      let current = [];
+      let past = [];
+      let all = [];
 
-        // look at each person at customer
-        // if person is a source, add to list(s)
-        _.each(customer.people, function(p) {
+      // look at each person at customer
+      // if person is a source, add to list(s)
+      _.each(customer.people, function(p) {
 
-          let source = _.find(person.sources, function(ps) {
-            if (!ps || !ps.person || !ps.person._id) { return false; }
-            return ps.person._id.toString() === p.person.toString();
-          });
+        let source = _.find(person.sources, function(ps) {
+          if (!ps || !ps.person || !ps.person._id) { return false; }
+          return ps.person._id.toString() === p.person.toString();
+        });
 
-          if (!source) { return; }
+        if (!source) { return; }
 
-          if (p.current) { current.push(source); }
-          if (!p.current) { past.push(source); }
+        if (p.current) { current.push(source); }
+        if (!p.current) { past.push(source); }
 
-          all.push(source);
+        all.push(source);
 
-        });
-
-        // return categorized sources
-        return cb(null, {
-          all: all,
-          current: current,
-          past: past
-        });
-
-      }).catch(function(err) { cb(err); });
+      });
 
-    }).catch(function(err) { cb(err); });
+      // return categorized sources
+      return cb(null, {
+        all: all,
+        current: current,
+        past: past
+      });
+    } catch(err) {
+      return cb(err);
+    }
   };
 
-  Person.statics.modify = function(filter, update, cb) {
+  Person.statics.modify = async function(filter, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -581,17 +598,20 @@ module.exports = function(mongoose, config) {
     if (!filter) { return cb(new Error('filter is required'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
-
-    // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
-    // options runValidators defaults false which is ok since we have upsert false
-    // new returns the updated document
+    try {
+      // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
+      // options runValidators defaults false which is ok since we have upsert false
+      // new returns the updated document
 
-    self.findOneAndUpdate(filter, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await this.findOneAndUpdate(filter, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.modifyById = function(id, update, cb) {
+  Person.statics.modifyById = async function(id, update, cb) {
 
     // VERY IMPORTANT NOTE
     // findByIdAndUpdate and findOneAndUpdate do not trigger pre-save hook so that code will not run here
@@ -602,13 +622,16 @@ module.exports = function(mongoose, config) {
     if (!mongoose.Types.ObjectId.isValid(id)) { return cb(new Error('id is not a valid ObjectId'), null); }
     if (!update) { return cb(new Error('update is required'), null); }
 
-    var self = this;
+    try {
+      // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
+      // options runValidators defaults false which is ok since we have upsert false
+      // new returns the updated document
 
-    // https://mongoosejs.com/docs/api.html#model_Model.findOneAndUpdate
-    // options runValidators defaults false which is ok since we have upsert false
-    // new returns the updated document
-
-    self.findByIdAndUpdate(id, update, { upsert: false, new: true }).then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+      const result = await this.findByIdAndUpdate(id, update, { upsert: false, new: true });
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
@@ -631,13 +654,12 @@ module.exports = function(mongoose, config) {
   // 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) {
+  Person.statics.search = async 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) {
@@ -927,28 +949,28 @@ module.exports = function(mongoose, config) {
 
     query = buildQuery(data, options);
 
-    self
-      .find(query)
-      .select('avatarUrl name title related')
-      .exec().then(function(people) {
+    try {
+      const people = await this
+        .find(query)
+        .select('avatarUrl name title related');
       if (!people) return cb(null, null);
-        else {
-
-          if (options.removeRelatedFromTopLevel) people = removeRelatedFromTopLevel(people);
+      else {
 
-          people = _.sortBy(people, function(person) { return person.name.full; });
+        let result = people;
+        if (options.removeRelatedFromTopLevel) result = removeRelatedFromTopLevel(people);
 
-          return cb(null, people);
+        result = _.sortBy(result, function(person) { return person.name.full; });
 
-        }
+        return cb(null, result);
 
-      }).catch(function(err) { cb(err); });
+      }
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.search2 = function (query, options, cb) {
-
-    const self = this;
+  Person.statics.search2 = async function (query, options, cb) {
 
     const defaultOptions = {
       limit: 10,
@@ -959,91 +981,99 @@ module.exports = function(mongoose, config) {
     // combine provided and default options
     options = _.defaults(options || {}, defaultOptions);
 
-    self.aggregate([
-      {
-        "$search": {
-          index: 'default',
-          compound: {
-            should: [
-              {
-                text: {
-                  query: query,
-                  path: [
-                    'name.first',
-                    'name.last',
-                    'fullName',
-                    'aliases',
-                    'contact.email.email'
-                  ]
-                }
-              },
-              {
-                autocomplete: {
-                  query: query,
-                  path: 'name.first'
-                }
-              },
-              {
-                autocomplete: {
-                  query: query,
-                  path: 'name.last'
+    try {
+      const people = await this.aggregate([
+        {
+          "$search": {
+            index: 'default',
+            compound: {
+              should: [
+                {
+                  text: {
+                    query: query,
+                    path: [
+                      'name.first',
+                      'name.last',
+                      'fullName',
+                      'aliases',
+                      'contact.email.email'
+                    ]
+                  }
+                },
+                {
+                  autocomplete: {
+                    query: query,
+                    path: 'name.first'
+                  }
+                },
+                {
+                  autocomplete: {
+                    query: query,
+                    path: 'name.last'
+                  }
+                },
+                {
+                  autocomplete: {
+                    query: query,
+                    path: 'fullName'
+                  }
                 }
-              },
-              {
-                autocomplete: {
-                  query: query,
-                  path: 'fullName'
+              ],
+              must: [
+                {
+                  equals: {
+                    path: 'deleted',
+                    value: false
+                  }
                 }
-              }
-            ],
-            must: [
-              {
-                equals: {
-                  path: 'deleted',
-                  value: false
-                }
-              }
-            ]
+              ]
+            }
+          }
+        }, {
+          $limit: options.limit,
+        }, {
+          "$project": {
+            "_id": 1,
+            "fullName": 1,
+            "name": 1,
+            "avatarUrl": 1,
+            "sources": 1,
+            "emails": "$contact.email",
+            "score": { "$meta": "searchScore" }
           }
         }
-      }, {
-        $limit: options.limit,
-      }, {
-        "$project": {
-          "_id": 1,
-          "fullName": 1,
-          "name": 1,
-          "avatarUrl": 1,
-          "sources": 1,
-          "emails": "$contact.email",
-          "score": { "$meta": "searchScore" }
-        }
-      }
-    ]).exec().then(function(people) {people = _.map(people, function(person) {
+      ]);
+
+      const cleaned = _.map(people, function(person) {
         return helpers.cleanPerson(person, options.CUSTOMER_ID);
       });
 
-      return cb(null, people);
-
-    }).catch(function(err) { cb(err); });
+      return cb(null, cleaned);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.searchByEmail = function(email, cb) {
+  Person.statics.searchByEmail = async function(email, cb) {
 
     if (!cb) throw new Error('cb is required');
     if (!email) return cb(new Error('email is required to search by email'), null);
 
     email = email.toString().toLowerCase();
 
-    this
-      .find({ 'contact.email.email': email, 'deleted': {$ne: true} })
-      .select('name avatarUrl')
-      .exec().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await this
+        .find({ 'contact.email.email': email, 'deleted': {$ne: true} })
+        .select('name avatarUrl');
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };
 
-  Person.statics.upsert = function(currentPerson, username, cb) {
+  Person.statics.upsert = async 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); }
@@ -1053,7 +1083,12 @@ module.exports = function(mongoose, config) {
       on: new Date()
     };
 
-    currentPerson.save().then(function(result) { cb(null, result); }).catch(function(err) { cb(err); });
+    try {
+      const result = await currentPerson.save();
+      return cb(null, result);
+    } catch(err) {
+      return cb(err);
+    }
 
   };