@dhyasama/totem-models 1.0.0

package/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var bootstrap = function(mongoose, config) {
+
+  var env = process.env.NODE_ENV || 'development';
+
+  // turn on debug if in development and not explicitly turned off
+  mongoose.set('debug', (!config.suppressDebugLog && env == 'development'));//mongoose.set('debug',true);
+
+  // use bluebird promises globally within mongoose
+  mongoose.Promise = require('bluebird');
+
+  // Validate config
+  var configHas_LPS_ENABLED = typeof config['LPS_ENABLED'] != 'undefined';
+  if (!configHas_LPS_ENABLED) throw new Error('Config is missing LPS_ENABLED setting');
+
+  var configHas_CUSTOMER_ID = typeof config['CUSTOMER_ID'] != 'undefined';
+  if (!configHas_CUSTOMER_ID) throw new Error('Config is missing CUSTOMER_ID setting');
+
+  require('./lib/Account.js')(mongoose, config);
+  require('./lib/Activity.js')(mongoose, config);
+  require('./lib/CalendarEvent.js')(mongoose, config);
+  require('./lib/Fund.js')(mongoose, config);
+  require('./lib/List.js')(mongoose, config);
+  require('./lib/News.js')(mongoose, config);
+
+  // note must be loaded before limited partner
+  // note must be loaded before organization
+  // note must be loaded before person
+  require('./lib/Note.js')(mongoose, config);
+
+  // organization must be loaded before limited partner
+  require('./lib/Organization.js')(mongoose, config);
+
+  // limited partner must be loaded before person
+  require('./lib/LimitedPartner.js')(mongoose, config);
+
+  require('./lib/Person.js')(mongoose, config);
+
+};
+
+module.exports = bootstrap;

package/lib/Account.js

@@ -0,0 +1,312 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    Crypto = require('@dhyasama/ffvc-crypto'),
+    crypto = new Crypto({'key': config.crypto.key}),
+    env = process.env.NODE_ENV || 'development',
+    bcrypt = require('bcrypt'),
+    _ = require('underscore');
+
+  var Account = new Schema({
+
+    username: { type: String, required: true, unique: true },
+    password: { type: String, default: '' },
+    email: { type: String, required: true, unique: true },
+    avatar: { type: String, default: '/media/abstract-cubes.png' },
+    reset: {
+      token: { type: String, default: '' },
+      expiresOn: { type: Date }
+    },
+    setup: {
+      token: { type: String, default: '' },
+      expiresOn: { type: Date },
+      complete: { type: Boolean, default: false },
+      terms: {
+        raw: { type: String },
+        hash: { type: String }
+      }
+    },
+    twoFactorAuth: {
+      enabled: { type: Boolean, default: true },
+      phone: { type: String, default: '' },
+      country: {
+        callingCode: { type: String, default: '' },
+        abbreviation:  { type: String, default: '' }
+      },
+      verified: { type: Boolean, default: false }
+    },
+    admin: { type: Boolean, default: false },
+    active: { type: Boolean, default: false },
+    subscriber: { type: Boolean, default: false },
+    role: { type: String, enum: ['admin', 'lp-full', 'lp-names', 'none'], default: 'none' },
+
+    // Enable this and iLevel links will show on portfolio pages
+    iLevelUser: { type: Boolean, default: false },
+
+    person: {
+      type: Schema.ObjectId,
+      ref: 'Person',
+      required: true
+    },
+
+    // todo - change to org
+    customer: {
+      type: Schema.ObjectId,
+      ref: 'Investor',
+      required: false
+    },
+
+    // todo - port from customer
+    org: {
+      type: Schema.ObjectId,
+      ref: 'Organization',
+      required: false
+    },
+
+    auth: {
+
+      strategy: { type: String, enum: ['google', 'microsoft', 'none'], default: 'none' },
+
+      google: {
+        accessToken: { type: String, default: '' },
+        refreshToken: { type: String, default: '' },
+        params: { type: Schema.Types.Mixed },
+        profile: { type: Schema.Types.Mixed },
+        watch: { type: Schema.Types.Mixed },
+        nextSyncToken: { type: String, default: null }
+      },
+
+      microsoft: {
+        accessToken: { type: String, default: '' },
+        refreshToken: { type: String, default: '' },
+        params: { type: Schema.Types.Mixed },
+        profile: { type: Schema.Types.Mixed },
+        watch: { type: Schema.Types.Mixed }
+      }
+
+    },
+
+    calendar: {
+      active: { type: Boolean, default: false },       // only pull if this is active
+      forcePullAll: { type: Boolean, default: false }  // override newest event date as min and go back all the way
+    }
+
+  });
+
+  Account.methods.phone = function() {
+    return this.twoFactorAuth.country.callingCode + this.twoFactorAuth.phone;
+  };
+
+  Account.statics.getById = function (id, cb) {
+
+    this
+      .findById(id)
+      .populate('person org')
+      .exec(function (err, account) {
+        if (err) {
+          return cb(err, null);
+        }
+        else if (account && account.person) {
+          account.deepPopulate('person.lps.lp', function (err, result) {
+            return cb(err, account);
+          });
+        }
+        else if (!account) {
+          return cb(new Error('No account with id ' + id.toString()), null);
+        }
+        else if (account && !account.person) {
+          return cb(new Error('Missing person reference on account with id ' + id.toString()), null);
+        }
+        else {
+          return cb(new Error('Unknown error'), null);
+        }
+      });
+
+  };
+
+  Account.statics.getByPersonIds = function (ids, cb) {
+    this
+      .find({ 'person': { $in : ids } })
+      .populate('person', 'name')
+      .exec(cb);
+  };
+
+  Account.statics.upsert = function(account, cb) {
+    account.save(cb);
+  };
+
+  Account.statics.findByUsername = function(username, cb) {
+    this
+      .findOne({ 'username': new RegExp(username, 'i') })
+      .populate('person')
+      .exec(function (err, account) {
+        cb(err, account);
+      });
+  };
+
+  Account.statics.findByEmail = function(email, cb) {
+    this
+      .findOne({ 'email': email})
+      .populate('person')
+      .exec(function (err, account) {
+        cb(err, account);
+      });
+  };
+
+  Account.statics.findByffEmail = function(email, cb) {
+    email = email.toLowerCase();
+
+    if (email.indexOf('@ffvc.com') > -1) {
+      this
+        .findOne({ 'email': email})
+        .populate('person')
+        .exec(function (err, account) {
+          cb(err, account);
+        });
+    } else {
+      //passing in null err so passport hits failureRedirect: '/login'
+      cb(null, null);
+    }
+  };
+
+  Account.statics.findByResetToken = function(token, cb) {
+    this
+      .findOne({ 'reset.token': token})
+      .populate('person')
+      .exec(function (err, account) {
+        cb(err, account);
+      });
+  };
+
+  Account.statics.findBySetupToken = function(token, cb) {
+    this
+      .findOne({ 'setup.token': token})
+      .populate('person')
+      .exec(function (err, account) {
+        cb(err, account);
+      });
+  };
+
+  Account.statics.findByCredentials = function (username, cleartextPassword, cb) {
+
+    this
+      .findOne({ 'username': new RegExp(username, 'i') })
+      .populate('person')
+      .exec(function (err, account) {
+
+        if (err) {
+          return cb(err, null);
+        }
+        else if (account != null) {
+
+          // found user, now check password
+
+          bcrypt.compare(cleartextPassword, account.password, function(err, res) {
+            if (err) { return cb(err, null); } // error
+            else if (res) { return cb(null, account); } // correct password
+            else { return cb(null, null); } // wrong password
+          });
+
+        }
+        else {
+          return cb(null, null); // user not found
+        }
+
+      });
+
+  };
+
+  Account.statics.listGoogleAccounts = function(cb) {
+
+    this
+      .find({
+        'active': true,
+        'calendar.active': true,
+        'auth.strategy': 'google',
+        'auth.google.refreshToken': { $ne: null }
+      })
+      .exec(cb);
+
+  };
+
+  Account.statics.listAllAccounts = function (cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+
+    this
+      .find({'active': true})
+      .populate('person')
+      .exec(function (err, accounts) {
+        return cb(err, _.sortBy(accounts, function(account) {
+          if (account.person && account.person.name && account.person.name.last) {
+            return account.person.name.last;
+          }
+          else return '';
+        }));
+      });
+
+  };
+
+  Account.statics.listAllAccountsSkinny = function (cb) {
+
+    // sort is done post retrieval because query sort is done pre-decryption
+    this
+      .find({'active': true})
+      .exec(cb);
+
+  };
+
+  //Account.pre('save', function(next) {
+  //
+  //  // Encrypt sensitive data
+  //
+  //  if (this.auth) {
+  //    if (this.auth.google) {
+  //      if (this.auth.google.accessToken) this.auth.google.accessToken = crypto.encrypt(this.auth.google.accessToken);
+  //      if (this.auth.google.refreshToken) this.auth.google.refreshToken = crypto.encrypt(this.auth.google.refreshToken);
+  //      if (this.auth.google.params) {
+  //        if (this.auth.google.params.access_token) this.auth.google.params.access_token = crypto.encrypt(this.auth.google.params.access_token);
+  //        if (this.auth.google.params.id_token) this.auth.google.params.id_token = crypto.encrypt(this.auth.google.params.id_token);
+  //      }
+  //    }
+  //  }
+  //
+  //  next();
+  //
+  //});
+  //
+  //Account.post('init', function() {
+  //
+  //  // Decrypt sensitive data
+  //
+  //  if (this.auth) {
+  //    if (this.auth.google) {
+  //      if (this.auth.google.accessToken) this.auth.google.accessToken = crypto.decrypt(this.auth.google.accessToken);
+  //      if (this.auth.google.refreshToken) this.auth.google.refreshToken = crypto.decrypt(this.auth.google.refreshToken);
+  //      if (this.auth.google.params) {
+  //        if (this.auth.google.params.access_token) this.auth.google.params.access_token = crypto.decrypt(this.auth.google.params.access_token);
+  //        if (this.auth.google.params.id_token) this.auth.google.params.id_token = crypto.decrypt(this.auth.google.params.id_token);
+  //      }
+  //    }
+  //  }
+  //
+  //});
+
+  Account.post('remove', function(doc) {
+    // CalendarEvent.account
+    // Person.account
+  });
+
+  Account.set('autoIndex', true);
+  Account.on('index', function(err) { console.log('error building account indexes: ' + err); });
+
+  var deepPopulate = require('mongoose-deep-populate')(mongoose);
+  Account.plugin(deepPopulate);
+
+  mongoose.model('Account', Account);
+
+};

package/lib/Activity.js

@@ -0,0 +1,138 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    env = process.env.NODE_ENV || 'development',
+    Geoip = require('@dhyasama/ffvc-geoip'),
+    geoip = new Geoip(),
+    async = require('async'),
+    rangeCheck = require('range_check');
+
+  var Activity = new Schema({
+
+    username: { type: String, required: true, index: true },
+
+    items: [{
+
+      type: {
+        type: String,
+        required: true,
+        enum: [
+          'SETUP ACCOUNT',
+          'LOGIN SUCCESS',
+          'LOGIN FAILURE',
+          'NEW DEVICE',
+          'PASSWORD RESET',
+          'PASSWORD CHANGE',
+          'DOCUMENT DOWNLOAD',
+          'ACCOUNT CHANGE'
+        ]
+      },
+
+      timestamp: { type: Date },
+
+      remoteAddress: { type: String },
+
+      geolocation: {},
+
+      document: {
+        url: { type: String },
+        filename: { type: String }
+      }
+
+    }]
+
+  });
+
+
+
+  Activity.statics.add = function(username, type, remoteAddress, url, filename, callback) {
+
+    var self = this;
+
+    if (!username) throw new Error('username is required');
+    if (!type) throw new Error('type is required');
+    if (!callback) throw new Error('callback is required');
+
+    username = username.toLowerCase();
+
+    var getActivity = function(cb) {
+
+      self.findOne({ 'username': username }, function(err, activity) {
+
+        if (err) return cb(err, null);
+
+        if (!activity) {
+          var A = mongoose.model('Activity');
+          activity = new A();
+          activity.username = username;
+        }
+
+        return cb(null, activity);
+
+      });
+
+    };
+
+    var getGeolocation = function(cb) {
+      if (!rangeCheck.validIp(remoteAddress)) return cb(null, {});
+      geoip.locate(remoteAddress, cb);
+    };
+
+    var asyncFinally = function(err, results) {
+
+      var activity = results ? results[0] : {};
+      var geolocation = results ? results[1] : {};
+
+      var item = {
+        type: type,
+        timestamp: new Date(),
+        geolocation: geolocation
+      };
+
+      if (url) {
+        item.document = {
+          url: url,
+          filename: filename
+        };
+      }
+
+      if (activity) {
+        activity.items.unshift(item);
+        activity.save(function(err, result) {
+          return callback(err, item);
+        });
+      }
+      else {
+        return callback(null, null);
+      }
+
+    };
+
+    async.parallel([getActivity, getGeolocation], asyncFinally);
+
+  };
+
+  Activity.statics.forMessage = function(username, messageId, cb) {
+    this.find({ 'username': username.toLowerCase(), 'items.document.messageId': messageId }, cb);
+  };
+
+  Activity.statics.list = function(username, maxItems, cb) {
+
+    var query = this.findOne({ 'username': username.toLowerCase() });
+
+    if (maxItems && maxItems >= 1) { query = query.slice('items', maxItems); }
+
+    query.exec(cb);
+
+  };
+
+  Activity.set('autoIndex', true);
+  Activity.on('index', function(err) { console.log('error building activity indexes: ' + err); });
+
+  mongoose.model('Activity', Activity);
+
+};

package/lib/CalendarEvent.js

@@ -0,0 +1,150 @@
+"use strict";
+
+module.exports = function(mongoose, config) {
+
+  var
+
+    Schema = mongoose.Schema,
+    env = process.env.NODE_ENV || 'development',
+    _ = require('underscore');
+
+  var CalendarEvent = new Schema({
+
+    account: { type: Schema.ObjectId, ref: 'Account', index: true, required: true },
+
+    email: { type: String, index: true, required: true },
+
+    provider: { type: String, index: false, required: true },
+
+    eventId: { type: String, index: true, required: true },
+
+    status: { type: String, index: true, required: true },
+
+    summary: { type: String, index: false, required: true },
+
+    start: { type: Date, index: false, required: true },
+
+    end: { type: Date, index: false, required: true },
+
+    attendees: [{
+
+      email: { type: String, index: true, required: true },
+
+      displayName: { type: String, index: true, required: true }
+
+    }],
+
+    allInternal: { type: Boolean, index: true, required: true },
+
+    processed: { type: Boolean, index: true, required: true },
+
+    createdOn: { type: Date, index: false, required: true },
+
+    updatedOn: { type: Date, index: false, required: true },
+
+    importTransactionId: { type: String, index: true, required: false },
+
+    raw: { type: String, index: false, required: true }
+
+  });
+
+  CalendarEvent.virtual('original').get(function () {
+    return JSON.parse(this.raw);
+  });
+
+  CalendarEvent.statics.findByAccountId = function (accountId, cb) {
+    this
+      .find({ account: accountId })
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.findByCreatedRange = function (since, until, cb) {
+    this
+      .find({ createdOn: { $gt: since, $lt: since } })
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.findByCreatedSince = function (since, cb) {
+    this
+      .find({ createdOn: { $gt: since } })
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.findByEmail = function (email, cb) {
+    this
+      .find({ email: email })
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.findByEventId = function (eventId, cb) {
+    this
+      .findOne({ 'eventId': eventId })
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.findUnprocessedForAccount = function (id, cb) {
+    this
+      .find({ account: id, processed: false })
+      .populate('account', 'email customer')
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.findByUsername = function (username, cb) {
+    this
+      .find({ 'account.username': username })
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.getById = function (id, cb) {
+    this
+      .findOne({ '_id': id })
+      .populate('account', 'email customer')
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.getNewest = function (email, cb) {
+    this
+      .findOne({email: email})
+      .sort({createdOn:-1})
+      .exec(cb);
+  };
+
+  CalendarEvent.statics.upsert = function(calendarEvent, cb) {
+
+    var self = this;
+
+    // Prevent dupe events
+
+    var query = { 'eventId': calendarEvent.eventId };
+    var options = { 'upsert': true, 'new': true };
+    var update = {
+      account: calendarEvent.account,
+      email: calendarEvent.email,
+      provider: calendarEvent.provider,
+      eventId: calendarEvent.eventId,
+      status: calendarEvent.status,
+      summary: calendarEvent.summary,
+      start: calendarEvent.start,
+      end: calendarEvent.end,
+      attendees: calendarEvent.attendees,
+      allInternal: calendarEvent.allInternal,
+      processed: calendarEvent.processed,
+      createdOn: calendarEvent.createdOn,
+      updatedOn: calendarEvent.updatedOn,
+      raw: calendarEvent.raw
+    };
+
+    self.findOneAndUpdate(query, update, options, cb);
+
+  };
+
+  CalendarEvent.post('remove', function(doc) {
+    // Person.calendarEventId
+  });
+
+  CalendarEvent.set('autoIndex', true);
+  CalendarEvent.on('index', function(err) { console.log('error building calendar event indexes: ' + err); });
+
+  mongoose.model('CalendarEvent', CalendarEvent);
+
+};