slactbot

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           ______     ______     ______   __  __     __     ______
          /\  == \   /\  __ \   /\__  _\ /\ \/ /    /\ \   /\__  _\
          \ \  __<   \ \ \/\ \  \/_/\ \/ \ \  _"-.  \ \ \  \/_/\ \/
           \ \_____\  \ \_____\    \ \_\  \ \_\ \_\  \ \_\    \ \_\
            \/_____/   \/_____/     \/_/   \/_/\/_/   \/_/     \/_/


This is a sample Slack bot built with Botkit.

This bot demonstrates many of the core features of Botkit:

* Connect to Slack using the real time API
* Receive messages based on "spoken" patterns
* Reply to messages
* Use the conversation system to ask questions
* Use the built in storage system to store and retrieve information
  for a user.

# RUN THE BOT:

  Get a Bot token from Slack:

    -> http://my.slack.com/services/new/bot

  Run your bot from the command line:

   # token=<MY TOKEN> node bot.js
   
# USE THE BOT:

  Find your bot inside Slack to send it a direct message.

  Say: "Hello"

  The bot will reply "Hello!"

  Say: "who are you?"

  The bot will tell you its name, where it running, and for how long.

  Say: "Call me <nickname>"

  Tell the bot your nickname. Now you are friends.

  Say: "who am I?"

  The bot will tell you your nickname, if it knows one for you.

  Say: "shutdown"

  The bot will ask if you are sure, and then shut itself down.

  Make sure to invite your bot into other channels using /invite @<my bot>!

# EXTEND THE BOT:

  Botkit has many features for building cool and useful bots!

  Read all about it here:

    -> http://howdy.ai/botkit


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

process.env.token='xoxb-31951615347-LtGPlWzxloIeGez3RtzbagwA'

/*

if (!process.env.token) {
    console.log('Error: Specify token in environment');
    process.exit(1);
}
*/

var Botkit = require('./lib/Botkit.js');
var os = require('os');

var controller = Botkit.slackbot({
    debug: true,
});

var bot = controller.spawn({
    token: process.env.token
}).startRTM();


controller.hears(['hello', 'hi'], 'direct_message,direct_mention,mention', function(bot, message) {

    bot.api.reactions.add({
        timestamp: message.ts,
        channel: message.channel,
        name: 'robot_face',
    }, function(err, res) {
        if (err) {
            bot.botkit.log('Failed to add emoji reaction :(', err);
        }
    });


    controller.storage.users.get(message.user, function(err, user) {
        if (user && user.name) {
            bot.reply(message, 'Hello ' + user.name + '!!');
        } else {
            bot.reply(message, 'Hello.');
        }
    });
});

controller.hears(['call me (.*)', 'my name is (.*)'], 'direct_message,direct_mention,mention', function(bot, message) {
    var name = message.match[1];
    controller.storage.users.get(message.user, function(err, user) {
        if (!user) {
            user = {
                id: message.user,
            };
        }
        user.name = name;
        controller.storage.users.save(user, function(err, id) {
            bot.reply(message, 'Got it. I will call you ' + user.name + ' from now on.');
        });
    });
});

controller.hears(['what is my name', 'who am i'], 'direct_message,direct_mention,mention', function(bot, message) {

    controller.storage.users.get(message.user, function(err, user) {
        if (user && user.name) {
            bot.reply(message, 'Your name is ' + user.name);
        } else {
            bot.startConversation(message, function(err, convo) {
                if (!err) {
                    convo.say('I do not know your name yet!');
                    convo.ask('What should I call you?', function(response, convo) {
                        convo.ask('You want me to call you `' + response.text + '`?', [
                            {
                                pattern: 'yes',
                                callback: function(response, convo) {
                                    // since no further messages are queued after this,
                                    // the conversation will end naturally with status == 'completed'
                                    convo.next();
                                }
                            },
                            {
                                pattern: 'no',
                                callback: function(response, convo) {
                                    // stop the conversation. this will cause it to end with status == 'stopped'
                                    convo.stop();
                                }
                            },
                            {
                                default: true,
                                callback: function(response, convo) {
                                    convo.repeat();
                                    convo.next();
                                }
                            }
                        ]);

                        convo.next();

                    }, {'key': 'nickname'}); // store the results in a field called nickname

                    convo.on('end', function(convo) {
                        if (convo.status == 'completed') {
                            bot.reply(message, 'OK! I will update my dossier...');

                            controller.storage.users.get(message.user, function(err, user) {
                                if (!user) {
                                    user = {
                                        id: message.user,
                                    };
                                }
                                user.name = convo.extractResponse('nickname');
                                controller.storage.users.save(user, function(err, id) {
                                    bot.reply(message, 'Got it. I will call you ' + user.name + ' from now on.');
                                });
                            });



                        } else {
                            // this happens if the conversation ended prematurely for some reason
                            bot.reply(message, 'OK, nevermind!');
                        }
                    });
                }
            });
        }
    });
});


controller.hears(['shutdown'], 'direct_message,direct_mention,mention', function(bot, message) {

    bot.startConversation(message, function(err, convo) {

        convo.ask('Are you sure you want me to shutdown?', [
            {
                pattern: bot.utterances.yes,
                callback: function(response, convo) {
                    convo.say('Bye!');
                    convo.next();
                    setTimeout(function() {
                        process.exit();
                    }, 3000);
                }
            },
        {
            pattern: bot.utterances.no,
            default: true,
            callback: function(response, convo) {
                convo.say('*Phew!*');
                convo.next();
            }
        }
        ]);
    });
});


controller.hears(['uptime', 'identify yourself', 'who are you', 'what is your name'],
    'direct_message,direct_mention,mention', function(bot, message) {

        var hostname = os.hostname();
        var uptime = formatUptime(process.uptime());

        bot.reply(message,
            ':robot_face: I am a bot named <@' + bot.identity.name +
             '>. I have been running for ' + uptime + ' on ' + hostname + '.');

    });


function formatUptime(uptime) {
    var unit = 'second';
    if (uptime > 60) {
        uptime = uptime / 60;
        unit = 'minute';
    }
    if (uptime > 60) {
        uptime = uptime / 60;
        unit = 'hour';
    }
    if (uptime != 1) {
        unit = unit + 's';
    }

    uptime = uptime + ' ' + unit;
    return uptime;
}

controller.hears(['double (.*)'],'direct_mention',function(bot, message) {
    var matches = message.text.match(/double (.*)/i);
    var msg = matches[1];
    bot.reply(message,msg+' '+msg);
});

controller.hears(['(.*)emoji(.*)'],'message_received,message_received,direct_message,direct_mention,mention',function(bot, message) {
    bot.replyWithTyping(message, '' + getRandomSmileEmoji());
});

function getRandomSmileEmoji(){
    var emojiArray = [
        ':grinning:',
        ':gokijet:',
        ':saitou:',
        ':grimacing:',
        ':grin:',
        ':roach_sleep:',
        ':smiley:',
        ':smile:',
        ':roach_thief:',
        ':laughing:',
        ':yoshio:',
        ':wink:'
    ];
    var random = Math.floor(Math.random() * emojiArray.length);
    return emojiArray[random];
}

controller.hears(['(.*)google(.*)'],'message_received,direct_message,direct_mention,mention',function(bot, message) {
    bot.replyWithTyping(message, '' + getUrl('GOOGLE'));
});
controller.hears(['(.*)yahoo(.*)'],'message_received,direct_message,direct_mention,mention',function(bot, message) {
    bot.replyWithTyping(message, '' + getUrl('YAHOO'));
});
controller.hears(['(.*)news(.*)'],'message_received,direct_message,direct_mention,mention',function(bot, message) {
    bot.replyWithTyping(message, 'news within 1 hour: ' + getUrl('NEWS'));
});
controller.hears(['(.*)norikae(.*)'],'message_received,direct_message,direct_mention,mention',function(bot, message) {
    bot.replyWithTyping(message, '' + getUrl('NORIKAE'));
});

function getUrl(urlStr){
    if (urlStr == 'GOOGLE'){
     url = 'https://www.google.co.jp/';
     return url;
    }
    if (urlStr == 'YAHOO'){
     url = 'http://www.yahoo.co.jp/';
     return url;
    }
    if (urlStr == 'NEWS'){
     url = 'https://www.google.co.jp/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=%E3%83%8B%E3%83%A5%E3%83%BC%E3%82%B9&safe=off&tbs=qdr:h';
     return url;
    }
    if (urlStr == 'NORIKAE'){
     url = 'http://www.jorudan.co.jp/';
     return url;
    }
}

var botkit = require('botkit'),
    request = require('superagent');
    
var WIKIPEDIA_URL = 'https://ja.wikipedia.org/wiki/';
 
 
controller.spawn({
  token: process.env.token
}).startRTM();
 
controller.hears(['wiki (.*)'], ['message_received', 'direct_message','direct_mention','mention'], function(bot, msg) {
  // wiki xxx でうぃきぺでぃあの冒頭を拾ってくる
  var word = msg.match[1] || msg.match[2];
   
  request
    .get('https://ja.wikipedia.org/w/api.php')
    .query({
      format : 'json',
      action : 'query',
      prop   : 'extracts',
      exintro: '',
      explaintext: '',
      titles : word
    })
    .end(function (err, res) {
      var query = res.body.query;
 
      if (query && query.pages) {
        for (var p in query.pages) {
          var content = query.pages[p].extract;
 
          if (content) {
            // slackで引用スタイルを適用するために`>` をつける
            content = '> ' + content.replace(/\n/g, '\n> ');
          }
          else {
            content = '見つからなかった';
          }
 
          bot.reply(msg, [
              content,
              WIKIPEDIA_URL + word
          ].join('\r\n'));
          return;
        }
      }
    });
});

controller.hears(['nemui','zzz'],'message_received,message_received,direct_message,direct_mention,mention',function(bot, message) {
    bot.replyWithTyping(message, '' + getRandomSmileEmoji());
});

function getRandomSmileEmoji(){
    var emojiArray = [
        ':sleeping:',
        ':sleepy:',
        ':roach_sleep:',
        ':frog_sleep:',
    ];
    var random = Math.floor(Math.random() * emojiArray.length);
    return emojiArray[random];
}