Utilizing Autobot for plank time recording

.gitignore

@@ -1,5 +1,6 @@
 #Credentials
-*/*_credentials.js
+configs/*.js
+configs/*.json
 
 # Logs
 logs

configs/google_credentials.js.example

@@ -0,0 +1 @@
+module.exports.spreadsheetId = 'you will never know';

configs/slack_token.js.example

@@ -1 +1 @@
-module.exports.slackToken = 'blah';
+module.exports.slackTokens = ['blah', 'blah2'];

configs/user_mappings.js.example

@@ -0,0 +1,15 @@
+module.exports.nameIndexMapper = {
+  mang: 1,
+  idiota: 2,
+  pendejo: 3,
+  womang: 4,
+  chola: 5
+}
+
+module.exports.nameLetterMapper = {
+  mang: "A",
+  idiota: "B",
+  pendejo: "C",
+  womang: "D",
+  chola: "E"
+}

handler.js

@@ -1,10 +1,13 @@
 'use strict';
 
 var qs = require('querystring');
-var slackToken = require('./configs/slack_token').slackToken;
+var slackTokens = require('./configs/slack_token').slackTokens;
 var Autobot = require('./main/autobot');
+var _= require('underscore');
 
-module.exports.slack = function(event, context, callback) {
+module.exports.slack = function(event, context, callback) {};
+
+module.exports.updateSheet = function(event, context, callback) {
 
   var statusCode, text;
   var body = event.body;
@@ -23,12 +26,12 @@ module.exports.slack = function(event, context, callback) {
     context.fail(err);
   };
 
-  if (requestToken !== slackToken) {
+  if (_.contains(slackTokens, requestToken)) {
+    var autobot = new Autobot('slack', 'google');
+    autobot.receive(params).then(success, failure);
+  } else {
       console.error("Request token (%s) does not match exptected", requestToken);
       context.fail("Invalid request token");
       callback("Invalid request token");
-  } else {
-    var autobot = new Autobot('slack');
-    autobot.receive(params.text).then(success, failure);
   }
 };

main/autobot.js

@@ -3,11 +3,14 @@
 var Handler = require('./autobot/handler');
 var access = require('./lib/resource_accessor').access;
 var Adapters = require('./autobot/adapters');
+var googleCore = require('./autobot/core/core').google;
+var defaultCore = require('./autobot/core/core').default;
 
 class Autobot {
-  constructor(adapter) {
+  constructor(adapter, coreType) {
     var adapterClass = access(Adapters, adapter);
-    this.adapter = new adapterClass();
+    if(coreType == 'google') { this.adapter = new adapterClass(googleCore); }
+    else { this.adapter = new adapterClass(defaultCore); }
   }
 
   receive(input) {

main/autobot/adapters/cli.js

@@ -2,6 +2,78 @@
 
 var Adapter = require('../adapters/adapter');
 
+class Parser {
+  constructor(input) {
+    this.input = input;
+    this.commandIndex = 0;
+    this.argsIndex = 1;
+  }
+
+  parse() {
+    if(this.input) {
+      var command = this.fetchCommand();
+
+      switch(command) {
+        case 'update':
+          return this.parseUpdate();
+        case 'chart':
+          return this.parseChart();
+        case 'interpolate':
+          return this.parseInterpolate();
+        default:
+          return this.parseDefault();
+      }
+    }
+    else {
+      return { command: '', args: {} }
+    }
+  }
+
+  fetchCommand() {
+    return this.input.trim().split(' ')[this.commandIndex];
+  }
+
+  parseUpdate() {
+    var regexUsers = /(@?)([a-zA-Z]*)(:?)(\ )*(\d+)/gi
+    var regexUser = /(@?)([a-zA-Z]*)(:?)(\ )*(\d+)/i
+
+    var matchedUsers = this.input.match(regexUsers);
+    var usernameGroup = 2;
+    var timeGroup = 5;
+    var parsedArgs = {};
+
+    for(var i = 0; i < matchedUsers.length; i++) {
+      var matchedUser = matchedUsers[i].match(regexUser);
+      var username = matchedUser[usernameGroup];
+      var plankTime = matchedUser[timeGroup];
+
+      parsedArgs[username] = plankTime;
+    };
+
+    return { command: 'update', args: parsedArgs };
+  }
+
+  parseChart() {
+    var regexUsers = /[a-zA-z]+/gi
+    var matchedUsers = this.input.match(regexUsers);
+
+    return { command: 'chart', args: matchedUsers };
+  }
+
+  parseInterpolate() {
+    var regexUsers = /([a-zA-z]+)/gi
+    var matchedUsers = this.input.match(regexUsers).slice(this.argsIndex);
+
+    return { command: 'interpolate', args: matchedUsers };
+  }
+
+  parseDefault() {
+    var command = this.fetchCommand();
+    var args = this.input.split(' ').slice(this.argsIndex);
+    return { command: command, args: args }
+  }
+}
+
 class Cli extends Adapter {
 
   /* Right now this parsing is very dumb.
@@ -10,11 +82,10 @@ class Cli extends Adapter {
            for more intelligent mapping.
   */
   parse(input) {
-    var tokens = input.trim().split(' ');
-    return { command: tokens[0], args: tokens.slice(1) }
+    var parser = new Parser(input)
+    return parser.parse();
   }
 
-
   /*
     TODO: Have an object whose responsibility it is to render
           this data depending on what kind of data it is?

main/autobot/adapters/slack.js

@@ -1,15 +1,113 @@
 'use strict';
 
 var Adapter = require('../adapters/adapter');
+class Parser {
+  constructor(input) {
+    if(input.text) {
+      this.input = input.text;
+      this.username = input.user_name;
+    } else {
+      this.input = input;
+    }
+    this.commandIndex = 1;
+    this.argsIndex = 2;
+  }
+
+  parse() {
+    if(this.fetchGreeting() != null) {
+      return this.fetchGreeting();
+    } else if(this.input) {
+      var command = this.fetchCommand();
+
+      switch(command) {
+        case 'update':
+          return this.parseUpdate();
+        case 'chart':
+          return this.parseChart();
+        case 'interpolate':
+          return this.parseInterpolate();
+        default:
+          return this.parseDefault();
+      }
+    } else {
+      return { command: '', args: {} }
+    }
+  }
+
+  fetchGreeting() {
+    var firstWord = this.input.trim().split(' ')[0];
+    var greetingsRegex = /^(greetings|hello|hi|hey|sup)/g
+
+    if(firstWord.match(greetingsRegex) != null) {
+      return { command: 'greetings', username: this.username, args: {} }
+    }
+
+    return null;
+  }
+
+  fetchCommand() {
+    return this.input.trim().split(' ')[this.commandIndex];
+  }
+
+  parseUpdate() {
+    var regexUsers = /(@?)([a-zA-Z]*)(:?)(\ )*(\d+)/gi
+    var regexUser = /(@?)([a-zA-Z]*)(:?)(\ )*(\d+)/i
+
+    var matchedUsers = this.input.match(regexUsers);
+    var usernameGroup = 2;
+    var timeGroup = 5;
+    var parsedArgs = {};
+
+    for(var i = 0; i < matchedUsers.length; i++) {
+      var matchedUser = matchedUsers[i].match(regexUser);
+      var username = matchedUser[usernameGroup];
+      var plankTime = matchedUser[timeGroup];
+
+      parsedArgs[username] = plankTime;
+    };
+
+    return { command: 'update', args: parsedArgs };
+  }
+
+  parseChart() {
+    var regexUsers = /[a-zA-z]+/gi
+    var matchedUsers = this.input.match(regexUsers).slice(this.argsIndex);
+
+    return { command: 'chart', args: matchedUsers };
+  }
+
+  parseInterpolate() {
+    var regexUsers = /([a-zA-z]+)/gi
+    var matchedUsers = this.input.match(regexUsers).slice(this.argsIndex);
+
+    return { command: 'interpolate', args: matchedUsers };
+  }
+
+  parseDefault() {
+    var command = this.fetchCommand();
+    var args = this.input.split(' ').slice(this.argsIndex);
+    return { command: command, args: args }
+  }
+}
 
 class Slack extends Adapter {
   parse(input) {
-    var tokens = input.split(' ');
-    return { command: tokens[1], args: tokens.slice(2) }
+    var parser = new Parser(input);
+    return parser.parse();
   }
 
   render(data) {
-    return { text: JSON.stringify(data) };
+    //responseData = JSON.stringify(data);
+    //console.log(data);
+    if(data['totalUpdatedColumns']) {
+      if(data['totalUpdatedColumns'] == 2) {
+        return { text: 'Successfully updated 1 record!' }
+      } else  {
+        return { text: 'Sucessfully updated ' + (data['totalUpdatedColumns'] - 1) + ' records!' };
+      }
+    } else {
+      return { text: data }
+    }
   }
 }
 

main/autobot/cli.js

@@ -6,7 +6,7 @@ repl.start({
 });
 
 var Autobot = require('../autobot');
-var dudeBot = new Autobot('slack');
+var dudeBot = new Autobot('cli', 'google');
 
 function evalAutobot(input, context, filename, callback) {
     dudeBot.receive(input).then(callback);

main/autobot/core/core.js

@@ -1,8 +1,11 @@
 'use strict';
 
 var jiraResource = require('../resources/jira');
+var googleResource = require('../resources/google/google');
 var access = require('../../lib/resource_accessor').access;
 
+var doNothing = new Promise(function(resolve, reject) { resolve(); });
+
 class Core {
   constructor(commands, resource) {
     this.resource = resource;
@@ -26,13 +29,32 @@ class Core {
     var commandToken = inputTokens['command'];
     var args         = inputTokens['args'];
 
-    var cmd = access(this.commands, commandToken).bind(this);
+    if(commandToken == '') { return doNothing; }
+    else if(commandToken == 'greetings') {
+      var username = inputTokens['username'];
+      var cmd = access(this.commands, commandToken).bind(this);
+      return cmd(username);
+    } else {
+      var cmd = access(this.commands, commandToken).bind(this);
+      return cmd(args);
+    }
+  }
 
-    return cmd(args);
+  type() {
+    return access(this.commands, 'type').bind(this).call();
   }
 }
 
-var commands = {
+// Returns a random integer between min (included) and max (excluded)
+// Using Math.round() will give you a non-uniform distribution!
+function getRandomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min)) + min;
+}
+
+var defaultCommands = {
+  type: function() { return 'default'; },
   /*
     A simple echo call.
 
@@ -64,5 +86,48 @@ var commands = {
   }
 }
 
+var googleCommands = {
+  type: function() { return 'google';},
+
+  greetings: function(username) {
+    var motivations = [
+      " Ready to give a good plank today?",
+      " Good stuff today! Let's keep it going!",
+      " You're pretty cool, but can you plank?",
+      " Let's see what you can do today!"
+    ];
+    var emojis = [
+      " :sweat_drops:",
+      " :fuck_yes:",
+      " :punch:",
+      " :yoga:"
+    ];
+
+    var motivationIndex = getRandomInt(0,4);
+    var emojiIndex = getRandomInt(0,4);
+    return new Promise(function(resolve, reject) {
+      var returnString = "Hey @" + username + "!" + motivations[motivationIndex] + emojis[emojiIndex];
+      resolve(returnString);
+    });
+  },
+
+  get: function(args) {
+    return this.resource.get(args);
+  },
+
+  chart: function(args) {
+    return this.resource.chart(args);
+  },
+
+  interpolate: function(args) {
+    return this.resource.interpolate(args);
+  },
+
+  update: function(args) {
+    return this.resource.update(args);
+  }
+}
+
 module.exports.Core = Core;
-module.exports.default = new Core(commands, jiraResource);
+module.exports.default = new Core(defaultCommands, jiraResource);
+module.exports.google  = new Core(googleCommands, googleResource);