init: (token, config, callback) => {
const controller = Botkit.slackbot(config);
controller.spawn({ token: token }).startRTM((error, bot, response) => {
if (error) {
console.error(error);
process.exit(1);
}
if (callback) callback(bot);
});
return controller;
}
module.exports = (function( token ){
var controller = Botkit.slackbot({
debug: false,
});
var bot = controller.spawn({
token: token
}).startRTM();
return {
bot: bot,
controller: controller
}
});
return new Promise((resolve, reject) => {
let controller = Botkit.slackbot({
debug: constants.get('botkit.debug'),
url: santo // only 1 webhook
});
let bot = controller.spawn({
token: constants.get('slack.token')
}).startRTM((err) => {
if (err) {
reject(new Error(err));
return;
}
resolve(new BotkitModel(controller, bot));
});
});
function Bot(options) {
var self = this;
self.options = _.extend({}, DEFAULT_BOT_OPTIONS, options);
winston.info("Loading config from: " + self.options.config_file);
self.config = require(self.options.config_file);
if (!self.config.token) {
winston.error('Failed to load token from: ' + self.options.config_file);
throw new Error("A token must be specified in the configuration file");
}
var bot_options = {
debug: self.options.debug
};
self.controller = Botkit.slackbot(bot_options);
self.controller.spawn({
token: self.config.token
}).startRTM(function(err, bot) {
// Store a reference to the bot so that we can use it later.
self.bot = bot;
if (err) {
throw new Error(err);
}
// connect to the database
models.connect(self.config).then(function() {
//winston.debug(bot === self);
//refresh your user and channel list every 2 minutes
//would be nice if this was push model, not poll but oh well.
refresh(bot, 120 * SECONDS, self.config);
});
});
winston.level = 'silly';
// setup logging
// Only log to slack if the token is set.
if (self.config.winston.token) {
winston.add(logging.Slack, self.config.winston);
}
self.hears = hears;
self.on = on;
self.startPrivateConversation = startPrivateConversation;
}
constructor(config) {
this.config = {
spawn: true,
debug: true,
log: undefined
};
Object.assign(this.config, config);
this.port = this.config.port || process.env.PORT || 8080;
this.botName = this.config.botName || 'proto-bot';
this.botTriggers = [];
this.taggedMessage = 'direct_message,direct_mention,mention';
this.untaggedMessage = 'direct_message,direct_mention,mention,ambient';
this.botListener = Botkit.slackbot({
debug: this.config.debug,
log: this.config.log
});
this.botListener.on('tick', () => {});
this.bot = this.botListener.spawn({
token: process.env.token
}).startRTM();
this.botListener.setupWebserver(this.port, (err,express_webserver) => {
this.botListener.createWebhookEndpoints(express_webserver);
});
this.automatonoAdapter = new AutomatonoAdapter({ bot: this.botListener });
this.automatono = new Automatono({ adapter: this.automatonoAdapter, log: this.config.log });
this.addUntaggedTrigger(['rise and shine$', 'roll call$', 'role call$'], this.rollCall.bind(this));
this.addTaggedTrigger(['help'], this.listFunctions.bind(this));
this.noDoze();
}
test.cb('create a bot instance.', t => {
const controller = botkit.slackbot({debug: false});
controller.on('rtm_open', bot => {
t.true(typeof bot === 'object');
});
controller.on('rtm_close', bot => {
t.true(typeof bot === 'object');
t.end();
controller.shutdown();
});
controller.spawn({token: env.SLACK_TOKEN}).startRTM((error, bot) => {
t.falsy(error);
t.true(typeof bot === 'object');
bot.closeRTM();
});
});
function init() {
clearInterval(ticTock);
smartBot = Botkit.slackbot();
dumbBot = new SlackBot({
token: process.env.SLACK_BOT_TOKEN,
name: process.env.SLACK_BOT_NAME
});
const onSmartBotStart = new Bluebird((resolve, reject) => {
smartBot
.spawn({
token: process.env.SLACK_BOT_TOKEN
})
.startRTM((err, bot, payload) => {
if (err) {
return reject(err);
}
const team = payload.team;
const users = payload.users.filter(u => !u.deleted && !!u.profile);
userMgmt.init(team, users);
smartBot.on('rtm_close', () => {
const restartInXSecs = 30;
console.log(debugDispatcher.c.red(`RTM connection closed!!! Attempting to restart in ${restartInXSecs} seconds...`));
setTimeout(init, restartInXSecs * 1000);
});
return resolve();
})
;
});
const onSmartBotSocketOpen = new Bluebird(resolve => {
smartBot.on('rtm_open', bot => resolve(bot));
});
const onDumbBotStart = new Bluebird(resolve => {
dumbBot.on('start', () => resolve());
});
return Bluebird
.all([onSmartBotStart, onSmartBotSocketOpen, onDumbBotStart])
.then(() => {
registerSmartBotListeners();
return new Bluebird(resolve => {
ticTock = setTimeout(() => {
startTicking();
resolve();
}, 1000);
});
})
.error(() => {
console.log(debugDispatcher.c.red('Error'));
})
;
}
module.exports = (app) => {
var ambientCheck = require('./ambient-check')(app)
var controller = Botkit.slackbot({
retry: Infinity,
logger: botkitLogger(app.log)
})
var beepboop = BeepBoop.start(controller, {
debug: true,
logger: beepboopLogger(app.log)
})
// Send a message to the user that added the bot right after it connects
beepboop.on('botkit.rtm.started', function (bot, resource, meta) {
var slackUserId = resource.SlackUserID
if (meta.isNew && slackUserId) {
app.log.info('welcoming user %s', slackUserId)
bot.api.im.open({ user: slackUserId }, function (err, response) {
if (err) {
return app.log.error(err)
}
var dmChannel = response.channel.id
bot.say({channel: dmChannel, text: 'Thanks for adding me to your team!'})
bot.say({channel: dmChannel, text: '/invite me to a channel!'})
})
}
})
var atBot = ['direct_message', 'direct_mention', 'mention']
var allMessages = ['direct_message', 'direct_mention', 'mention', 'ambient']
controller.hears(['comment', 'say something', 'hey'], atBot, (bot, message) => {
// filter out a matching slash command
if (message.text === '/comment') {
return
}
bot.startTyping(message)
app.comments.newComment(message.team, (err, comment, commentId) => {
if (err) {
app.log.error(err.message)
}
bot.reply(message, comment || app.messages('NO_COMMENT'))
})
})
controller.hears(['shrug', 'dunno', 'dont know', "don't know", 'no idea', 'idk', 'hmmm'], allMessages, (bot, message) => {
// limit the amount of ambient responses
if (!ambientCheck(message.team)) {
return
}
bot.reply(message, ':thinking_face: ...')
bot.startTyping(message)
// make it seem like bot is typing a comment for a bit
setTimeout(() => {
bot.reply(message, app.messages('SHRUG_COMMENT'))
}, 2000)
})
controller.hears('spam', allMessages, (bot, message) => {
bot.reply(message, ':exclamation: ARE YOU READY?!?!? :exclamation:')
bot.reply(message, ':exclamation::exclamation::exclamation: *ARE YOU READY?!?!?* :exclamation::exclamation::exclamation:')
var messageCount = 0
var interval = setInterval(function() {
bot.startTyping(message)
app.comments.newComment(message.team, (err, comment, commentId) => {
if (err) {
app.log.error(err.message)
}
bot.reply(message, ':rotating_light: :loudspeaker: :exclamation: :white_check_mark: :zap: :bangbang: :eight_spoked_asterisk: :heavy_check_mark: :soon: :mega: :clapping: :ballot_box_with_check: :pikachu: :beepbooping:')
bot.reply(message, comment || app.messages('NO_COMMENT_INITIATED'))
messageCount += 1
if (messageCount >= 10) {
clearInterval(interval)
}
})
}, 2000)
})
controller.hears(['420', 'weed', 'colorado', 'farm'], allMessages, (bot, message) => {
bot.reply(message, ':ok_hand::weed::ok_hand::eyes::dank_leaf::eyes::ok_hand::eyes::ok_hand::greg_in_colorado: good shit go౦ԁ sHit:ok_hand: thats :heavy_check_mark: some good:bong::ok_hand:shit right:ok_hand::greg_in_colorado:there:ok_hand::ok_hand::ok_hand: right:heavy_check_mark:there :heavy_check_mark::heavy_check_mark:if i do ƽaү so my self :100: i say so :100: thats what im talking about right there right there (chorus: ʳᶦᵍʰᵗ ᵗʰᵉʳᵉ) mMMMMᎷМ:100: :ok_hand::ok_hand: :ok_hand:НO0ОଠOOOOOОଠଠOoooᵒᵒᵒᵒᵒᵒᵒᵒᵒ:ok_hand: :weed::ok_hand: :dank_leaf: :100: :ok_hand: :eyes: :eyes: :420: :ok_hand::ok_hand:Good shit')
})
controller.hears('yahoo', allMessages, (bot, message) => {
// limit the amount of ambient responses
if (!ambientCheck(message.team)) {
return
}
bot.reply(message, app.messages('YAHOO_COMMENT'))
bot.startTyping(message)
app.comments.newComment(message.team, (err, comment, commentId) => {
if (err) {
app.log.error(err.message)
}
// make it seem like bot is typing a comment for a bit
setTimeout(() => {
bot.reply(message, comment || app.messages('NO_COMMENT_INITIATED'))
}, 2000)
})
})
controller.hears(['great', 'geez', 'wow', 'genius', 'seriously', 'yeah right', 'whatever', 'totally', 'lmao'], ['ambient'], (bot, message) => {
// limit the amount of ambient responses
if (!ambientCheck(message.team)) {
return
}
bot.reply(message, app.messages('SNARKY_COMMENT'))
bot.startTyping(message)
app.comments.newComment(message.team, (err, comment, commentId) => {
if (err) {
app.log.error(err.message)
}
// make it seem like bot is typing a comment for a bit
setTimeout(() => {
bot.reply(message, comment || app.messages('NO_COMMENT_INITIATED'))
}, 2000)
})
})
controller.hears(['ok', 'alright', 'just', 'still', 'agree', 'well,', 'team', 'basically', 'analysis', 'another', 'does', 'there', 'your'], ['ambient'], (bot, message) => {
// limit the amount of ambient responses
if (!ambientCheck(message.team)) {
return
}
bot.reply(message, app.messages('USELESS_COMMENT'))
bot.startTyping(message)
app.comments.newComment(message.team, (err, comment, commentId) => {
if (err) {
app.log.error(err.message)
}
// make it seem like bot is typing a comment for a bit
setTimeout(() => {
bot.reply(message, comment || app.messages('NO_COMMENT_INITIATED'))
}, 2000)
})
})
controller.hears(['good one', 'nice', 'thanks', 'wow', 'thank you'], atBot, (bot, message) => {
bot.reply(message, app.messages('THANKS'))
})
controller.hears(['help', 'what do you do'], atBot, (bot, message) => {
bot.reply(message, app.messages('HELP'))
})
}
process.exit(1);
}
var config = {}
if (process.env.MONGOLAB_URI) {
var BotkitStorage = require('botkit-storage-mongo');
config = {
storage: BotkitStorage({mongoUri: process.env.MONGOLAB_URI}),
};
} else {
config = {
json_file_store: './db_slackbutton_slash_command/',
};
}
var controller = Botkit.slackbot(config).configureSlackApp(
{
clientId: process.env.CLIENT_ID,
clientSecret: process.env.CLIENT_SECRET,
scopes: ['commands'],
}
);
controller.setupWebserver(process.env.PORT, function (err, webserver) {
controller.createWebhookEndpoints(controller.webserver);
controller.createOauthEndpoints(controller.webserver, function (err, req, res) {
if (err) {
res.status(500).send('ERROR: ' + err);
} else {
res.send('Success!');
'use strict';
// var SlackBot = require('slackbots');
var config = require('./config'),
connect = require('camo').connect,
MongoClient = require('mongodb').MongoClient,
exec = require('child_process').exec,
Botkit = require('botkit'),
url = require('url'),
Twit = require('twit'),
allowedUrlKeys = ["env", "lon", "lat", "zoom", "segments", "nodes", "cameras", "mapUpdateRequest", "mapProblem", "venues"],
// mongoStorage = require('botkit-storage-mongo')({mongoUri: 'mongodb://localhost/botkit'}),
controller = Botkit.slackbot({
// storage: mongoStorage,
debug: (process.env.CI),
port: config.server_port
//include "log: false" to disable logging
//or a "logLevel" integer from 0 to 7 to adjust logging verbosity
}),
T = new Twit({
consumer_key: process.env.TWITTER_KEY || "",
consumer_secret: process.env.TWITTER_SECRET || "",
app_only_auth: true
}),
express = require('express'),
bodyParser = require('body-parser'),
app = express(),
geocoderProvider = 'google', httpAdapter = 'http';
// optional
/*var extra = {
apiKey: 'YOUR_API_KEY', // for Mapquest, OpenCage, Google Premier
formatter: null // 'gpx', 'string', ...
'use strict';
const Promise = require('bluebird');
const Botkit = require('botkit');
const storage = require('botkit-storage-mongo')({ mongoUri: process.env.MONGO_URI });
let updates = [];
// Expect a SLACK_TOKEN environment variable
let token = process.env.SLACK_TOKEN;
if (!token) {
console.error('SLACK_TOKEN is required!');
process.exit(1);
}
let controller = Botkit.slackbot({ storage });
let bot = controller.spawn({ token });
let userSave = Promise.promisify(bot.botkit.storage.users.save);
let userGet = Promise.promisify(bot.botkit.storage.users.get);
bot.api.users.list({}, (err, res) => {
if (err) { throw err; }
res.members.forEach(member => {
userGet(member.id).then((user) => {
console.log('%s', member.name);
let updatedUser = {
id: member.id,
name: member.name,
real_name: member.profile.real_name_normalized,
var config = require('./config.json');
var fs = require('fs');
var _ = require('lodash');
var CronJob = require('cron').CronJob;
var Botkit = require('botkit');
var request = require('request');
var controller = Botkit.slackbot({
json_file_store: './db_slackbutton_bot/',
}).configureSlackApp(
{
clientId: "36097012757.37302654772",
clientSecret: "930dfec79d333917e9f3962d388933bb",
scopes: ['bot'],
}
);
controller.setupWebserver(3000,function(err,webserver) {
webserver.get('/channels', function (req, res) {
request('https://slack.com/api/channels.list?token=' + config.token, function (err, response, slackChannels) {
if (err) {
console.log(err);
} else {
res.status(200).send(JSON.parse(slackChannels).channels);
}
});
});
webserver.get('/users', function (req, res) {
request('https://slack.com/api/users.list?token=' + config.token, function (err, response, slackUsers) {
if (err) {
console.log(err);
// index.js :+: :+: :+: //
// +:+ +:+ +:+ //
// By: lperrigu <*****@*****.**> +#+ +:+ +#+ //
// +#+#+#+#+#+ +#+ //
// Created: 2016/08/09 19:11:43 by lperrigu #+# #+# //
// Updated: 2016/08/10 04:52:14 by lperrigu ### ########.fr //
// //
// ************************************************************************** //
var Botkit = require('botkit')
var token = process.env.SLACK_TOKEN
var controller = Botkit.slackbot({
// reconnect to Slack RTM when connection goes bad
retry: Infinity,
debug: false,
interactive_replies: true
});
// Assume single team mode if we have a SLACK_TOKEN
if (token) {
console.log('Starting in single-team mode')
controller.spawn({
token: token
}).startRTM(function (err, bot, payload) {
if (err) {
throw new Error(err)
}
console.log('Connected to Slack RTM')
})
if ((process.env.NODE_ENV || 'development') === 'development') {
require('dotenv').load();
}
Axios.get('http://webservices.nextbus.com/service/publicXMLFeed?command=predictions&a=ttc&stopId=4167')
.then(res => {
var parseString = require('xml2js').parseString;
parseString(res.data, function (err, result) {
var vehicle = result.body.vehicle.filter(i => i.$.lon < office.lng);
console.log('this is', vehicle);
});
});
const hugebot = Botkit.slackbot();
const bot = hugebot.spawn({
token: process.env.TOKEN
}).startRTM();
function randomText(choices) {
return choices[Math.floor(Math.random() * choices.length)];
};
//
hugebot.hears(['get me home'], 'direct_message,mention,direct_mention', (bot, msg) => {
bot.startConversation(msg, (res, convo) => {
convo.ask("Which way are you going? North, South, East or West?", function(response, convo) {
Axios.get('http://webservices.nextbus.com/service/publicXMLFeed?command=predictions&a=ttc&stopId=4167')
.then(res => {
var parseString = require('xml2js').parseString;
//TODO: 5) Get the NETADMIN course IDs and names and assign them appropriately
var moment = require('moment');
var Botkit = require('botkit');
var controller = Botkit.slackbot({
debug: false
//include "log: false" to disable logging
//or a "logLevel" integer from 0 to 7 to adjust logging verbosity
});
// connect the bot to a stream of messages
controller.spawn({
// Token for TestSlack
// token: ""
// Token for WGUIT
token: ""
}).startRTM()
// give the bot something to listen for.
controller.hears('hello',['direct_message','direct_mention','mention','ambient'],function(bot,message) {
bot.reply(message,'Hello yourself.');
});
controller.hears('\[Hh\]ey \[Hh\]oot',['ambient','mention'],function(bot,message) {
bot.reply(message,'Heya! Whatcha need?');
});
function spamCheck(spamTimer, durationMinutes)
{
// Recreate now everytime we hear something for accurate maths
* I wrote it, it kind of worked. That's the limit of my JS knowledge.
*/
'use strict'
// The botkit module
var BotKit = require('botkit');
// Export this module as Ears
module.exports = Ears;
/**
* Create a new botkit with debugging messages turned off
*/
var Bot = BotKit.slackbot({
debug: false,
});
/**
* Constructor for this module
*/
function Ears(token) {
this.scopes = [
'ambient',
'direct_mention',
'direct_message',
'mention'
];
this.token = token;
}
var Botkit = require('botkit');
if (!process.env.clientId || !process.env.clientSecret || !process.env.port) {
console.log('Error: Specify clientId clientSecret and port in environment');
process.exit(1);
}
var controller = Botkit.slackbot({
// interactive_replies: true, // tells botkit to send button clicks into conversations
json_file_store: './db_slackbutton_bot/',
}).configureSlackApp(
{
clientId: process.env.clientId,
clientSecret: process.env.clientSecret,
scopes: ['bot'],
}
);
controller.setupWebserver(process.env.port,function(err,webserver) {
controller.createWebhookEndpoints(controller.webserver);
controller.createOauthEndpoints(controller.webserver,function(err,req,res) {
if (err) {
res.status(500).send('ERROR: ' + err);
} else {
res.send('Success!');
}
});
});
// just a simple way to make sure we don't
var botkit = require('botkit');
var controller = botkit.slackbot();
//Put token in environment
var bot = controller.spawn({token : process.env.nickbot_token}).startRTM();
controller.hears(['Dance\?'],'ambient',function(bot, message) {
var restraurants = [
'Shoal Crossing',
'Paul\'s house',
];
var place = restraurants[Math.floor(Math.random()*restraurants.length)]
bot.reply(message,place);
});
controller.hears(['lunch\?'],'ambient',function(bot, message) {
var restraurants = [
'Tacos',
'Burgers',
'Pizza',
'Salads',
'Sandwiches',
];
var place = restraurants[Math.floor(Math.random()*restraurants.length)]
bot.reply(message,place);
});
controller.hears('Game','ambient',function(bot,message){
'use strict'
const _ = require('lodash')
const config = require('../config')
const trending = require('github-trending')
const Botkit = require('botkit')
var controller = Botkit.slackbot({})
var bot = controller.spawn()
bot.configureIncomingWebhook({ url: config('WEBHOOK_URL') })
const msgDefaults = {
response_type: 'in_channel',
username: '******',
icon_emoji: config('ICON_EMOJI')
}
trending('javascript', (err, repos) => {
if (err) throw err
var attachments = repos.slice(0, 5).map((repo) => {
return {
title: `${repo.owner}/${repo.title} `,
title_link: repo.url,
text: `_${repo.description}_\n${repo.language} • ${repo.star}`,
mrkdwn_in: ['text', 'pretext']
}
})
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
var ConfigFile = require('config');
if (!ConfigFile.token) {
console.log('Error: Specify token in config/default.yaml');
process.exit(1);
}
var Botkit = require('botkit');
var os = require('os');
var XMLHttpRequest = require('xhr2')
var controller = Botkit.slackbot({
debug: true,
retry: Infinity,
});
var bot = controller.spawn({
token: ConfigFile.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) {
var Botkit = require ('botkit')
var Witbot = require ('witbot')
var slackToken = process.env.SLACK_TOKEN
var witToken = process.env.WIT_TOKEN
var openWeatherApiKey = process.env.OPENWEATHER_KEY
var controller = Botkit.slackbot({
debug: false
})
controller.spawn({
token: slackToken
}).startRTM(function(err,bot,payload) {
if (err) {
throw new Error('Could not connect to slack: ', err)
}
console.log('Connected to slack')
})
var witbot = Witbot(witToken)
var weather = require('./weather')(openWeatherApiKey)
controller.hears('.*','direct_message,direct_mention', function (bot,message){
var wit = witbot.process(message.text, bot,message)
wit.hears('hello', 0.5,function(bot,message,outcome){
bot.reply(message,'Hello to you as well!')
})
wit.hears('weather',0.5, function(bot,message,outcome){
console.log(outcome.entities.location);
if (!outcome.entities.location || outcome.entities.location.length == 0){
bot.reply(message, 'I\'d like to give you the weather but for where?')
return
var express = require('express');
var port = process.env.PORT || 3002;
var App = require("app.json")
var app = App.new(__dirname + "/app.json");
var redisURL = url.parse(process.env.REDISCLOUD_URL);
var redisStorage = redis({
namespace: 'slack-quotebot',
host: redisURL.hostname,
port: redisURL.port,
auth_pass: redisURL.auth.split(":")[1]
});
var controller = Botkit.slackbot({
storage: redisStorage
}).configureSlackApp({
clientId: config.clientId,
clientSecret: config.clientSecret,
//change to your own redirectUri
redirectUri: 'https://slack-quoty.herokuapp.com/oauth',
scopes: ['bot', 'incoming-webhook', 'channels:read','commands']
});
// Not needed for now
//controller.on('direct_mention,ambient', function(bot, message) {
// console.log(message);
//});
controller.setupWebserver(port,function(err,webserver) {
webserver.use(express.static(__dirname + '/public'));
var Botkit = require('botkit');
var BotkitController = module.exports;
require('dotenv').config();
if (!process.env.token) {
console.log('Error: Specify token in environment');
process.exit(1);
}
BotkitController.controller = Botkit.slackbot({
debug: false,
json_file_store: __dirname + '/botdata'
});
BotkitController.usernames = {};
BotkitController.bot = this.controller.spawn({
token: process.env.token
}).startRTM(function(err, bot) {
// @ https://api.slack.com/methods/users.list
bot.api.users.list({}, function (err, response) {
if(err) {
bot.botkit.log('Failed to get the user list', err);
}
if (response.hasOwnProperty('members') && response.ok) {
var total = response.members.length;
for (var i = 0; i < total; i++) {
var member = response.members[i];
BotkitController.usernames[member.id] = member.name;
console.log('starting bot');
/* Seting up botkit under instructions*/
import botkit from 'botkit';
// botkit controller
const controller = botkit.slackbot({
debug: false,
});
// initialize slackbot
const slackbot = controller.spawn({
token: process.env.SLACK_BOT_TOKEN,
// this grabs the slack token we exported earlier
}).startRTM(err => {
// start the real time message client
if (err) { throw new Error(err); }
});
// prepare webhook
// for now we won't use this but feel free to look up slack webhooks
controller.setupWebserver(process.env.PORT || 3001, (err, webserver) => {
controller.createWebhookEndpoints(webserver, slackbot, () => {
if (err) { throw new Error(err); }
});
});
/* Setting up Yelp, https://github.com/olalonde/node-yelp*/
const Yelp = require('yelp');
'use strict';
if (!process.env.DASHBOT_API_KEY_SLACK) {
throw new Error('"DASHBOT_API_KEY_SLACK" environment variable must be defined');
}
if (!process.env.SLACK_BOT_TOKEN) {
throw new Error('"SLACK_BOT_TOKEN" environment variable must be defined');
}
const botkit = require('botkit');
const dashbot = require('../src/dashbot')(process.env.DASHBOT_API_KEY_SLACK,
{urlRoot: process.env.DASHBOT_URL_ROOT, debug:true}).slack;
const controller = botkit.slackbot();
controller.middleware.receive.use(dashbot.receive);
controller.middleware.send.use(dashbot.send);
controller.spawn({
token: process.env.SLACK_BOT_TOKEN
}).startRTM();
controller.on('direct_message', function(bot, message) {
if (message.text.length%2==0) {
bot.reply(message, 'You are right when you say: ' + message.text);
} else {
bot.reply(message, {
"attachments": [
{
"fallback": "Required plain-text summary of the attachment.",
function startSlackApp() {
var controller = Botkit.slackbot({
json_file_store: './db_slackbutton_bot/',
}).configureSlackApp(
{
clientId: "52190302359.52209798785",
clientSecret: "94822d98f44095d1e5606af506f11e98", //refresh these tokens when publishing :)
scopes: ['bot'],
}
);
controller.setupWebserver(3000,function(err,webserver) {
controller.createWebhookEndpoints(controller.webserver);
controller.createOauthEndpoints(controller.webserver,function(err,req,res) {
if (err) {
res.status(500).send('ERROR: ' + err);
} else {
res.send('Success!');
}
});
});
controller.on('create_bot',function(bot,config) {
if (_bots[bot.config.token]) {
// already online! do nothing.
}
else {
bot.startRTM(function(err) {
if (!err) {
trackBot(bot);
}
bot.startPrivateConversation({user: config.createdBy},function(err,convo) {
if (err) {
console.log(err);
} else {
convo.say('I am a bot that has just joined your team');
convo.say('You must now /invite me to a channel so that I can be of use!');
}
});
});
}
});
// Handle events related to the websocket connection to Slack
controller.on('rtm_open',function(bot) {
console.log('** The RTM api just connected!');
});
controller.on('rtm_close',function(bot) {
console.log('** The RTM api just closed');
// you may want to attempt to re-open
});
controller.hears('hello','direct_message',function(bot,message) {
bot.reply(message,'Hello!');
});
controller.hears('^stop','direct_message',function(bot,message) {
bot.reply(message,'Goodbye');
bot.rtm.close();
});
controller.hears('lint',['direct_message', 'direct_mention'], function(){
sendLintResultToUserWithEmail("nullstring")
});
controller.on(['direct_message','mention','direct_mention'],function(bot,message) {
bot.api.reactions.add({
timestamp: message.ts,
channel: message.channel,
name: 'robot_face',
},function(err) {
if (err) { console.log(err) }
bot.reply(message,'I heard you loud and clear boss.');
});
});
controller.storage.teams.all(function(err,teams) {
if (err) {
throw new Error(err);
}
// connect all teams with bots up to slack!
for (var t in teams) {
if (teams[t].bot) {
controller.spawn(teams[t]).startRTM(function(err, bot) {
if (err) {
console.log('Error connecting bot to Slack:',err);
} else {
trackBot(bot);
}
});
}
}
});
}
client.on('message', function (topic, message) {
// message is Buffer
let state = message.toString();
if (state == "on") {
led_state = true;
} else if (state == "off") {
led_state = false;
}
})
var botcontroller = Botkit.slackbot({
debug: false,
});
botcontroller.spawn({
token: creds.slack.token
}).startRTM(function(err, bot, payload) {
if (err) {
throw new Error(err);
}
});
botcontroller.hears(['hello', 'hi', 'howdy', 'hola'],
['direct_message','direct_mention','mention'],
function(bot,message) {
let user = `<@${message.user}>`;
let missingSettings = ['SLACK_TOKEN', 'WEATHER_API_KEY'].filter(setting => !process.env[setting]);
if (missingSettings.length > 0) {
console.log([
'Error, required settings missing:',
missingSettings.join('\n'),
`Env: ${JSON.stringify(process.env)}`].join('\n'));
process.exit(1);
}
let Botkit = require('botkit');
let os = require('os');
let weatherService = require('./services/weather_service');
let WeatherForecast = require('./models/weather_forecast');
let controller = Botkit.slackbot({
debug: process.env.DEBUG == 1
});
let bot = controller.spawn({
token: process.env.SLACK_TOKEN
}).startRTM();
controller.hears(['(.*) weather(\s*)(.*)?'], 'direct_message, direct_mention, mention', (bot, message) => {
let matches = message.text.match(/(.*) weather(\s*)(.*)?/i);
let locale = matches[1];
let timeScope = matches[3];
weatherService.fiveDayForecast(locale, data => {
let forecast = new WeatherForecast(data);
bot.reply(message, `${forecast.toString(timeScope)}`);
});
});
"use strict";
const SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
var express = require('express'),
app = express();
app.set('port', process.env.PORT || 5000);
let Botkit = require('botkit'),
formatter = require('./modules/slack-formatter'),
salesforce = require('./modules/salesforce'),
controller = Botkit.slackbot(),
bot = controller.spawn({
token: SLACK_BOT_TOKEN
});
bot.startRTM(err => {
if (err) {
throw new Error('Could not connect to Slack');
}
});
controller.hears(['help'], 'direct_message,direct_mention,mention', (bot, message) => {
bot.reply(message, {
text: `You can ask me things like:
"Search account Acme" or "Search Acme in acccounts"
"Search contact Lisa Smith" or "Search Lisa Smith in contacts"
"Search opportunity Big Deal"
var Botkit = require('botkit')
var beep = require('beepboop-botkit')
var request = require('request')
var parseString = require('xml2js').parseString
var htmlToText = require('html-to-text')
var token = process.env.SLACK_TOKEN
var controller = Botkit.slackbot({
// reconnect to Slack RTM when connection goes bad
retry: Infinity,
debug: false
})
// Assume single team mode if we have a SLACK_TOKEN
if (token) {
console.log('Starting in single-team mode')
controller.spawn({
token: token
}).startRTM(function (err, bot, payload) {
if (err) {
throw new Error(err)
}
console.log('Connected to Slack RTM')
})
// Otherwise assume multi-team mode - setup beep boop resourcer connection
} else {
console.log('Starting in Beep Boop multi-team mode')
beep.start(controller, { debug: true })
}