How to use botkit - 10 common examples

// const adapter = new HangoutsAdapter({
//     // enable_incomplete: true,
//     token: process.env.GOOGLE_TOKEN,
//     google_auth_params: {
//         credentials: JSON.parse(process.env['GOOGLE_CREDS'])
//     }
// });

// const adapter = new TwilioAdapter({
//     // enable_incomplete: true,
//     // twilio_number: process.env.TWILIO_NUMBER,
//     // account_sid: process.env.TWILIO_ACCOUNT_SID,
//     // auth_token: process.env.TWILIO_AUTH_TOKEN,
// });

const controller = new Botkit({
    debug: true,
    webhook_uri: '/api/messages',
    disable_console: true,
    adapter: adapter,
    // disable_webserver: true,
    // adapterConfig: {
    //     appId: process.env.APP_ID,
    //     appPassword: process.env.APP_PASSWORD
    // },
    storage
});

const cms = new BotkitCMSHelper({
    uri: process.env.cms_uri,
    token: process.env.cms_token,
});

// noop, just continue
            }
        }
    ],{key:'confirmed'});
    confirmation.say('All done!');
    confirmation.addGotoDialog(START_OVER,'try_again');

    const startover = new BotkitConversation(START_OVER, controller);
    startover.say('Lets start from the top...');
    startover.addChildDialog(PROFILE_DIALOG, 'profile');
    startover.addGotoDialog(CONFIRM_DIALOG);

    /**
     * Now, define a BotkitConversation style dialog that will use the profile dialog as a child.
     */
    const onboarding = new BotkitConversation(ONBOARDING_DIALOG, controller);
    onboarding.say('Hello, human! Nice to meet you.');
    onboarding.say('Before we begin, I need to ask you some questions.');
    onboarding.addChildDialog(PROFILE_DIALOG, 'profile');
    onboarding.say('Thanks, {{vars.profile.name}}! Your onboarding has completed.');
    onboarding.addGotoDialog(CONFIRM_DIALOG);

    /**
     * Add all of our dialogs to the bot.
     */
    controller.addDialog(textPrompt);
    controller.addDialog(profile);
    controller.addDialog(onboarding);
    controller.addDialog(confirmation);
    controller.addDialog(startover);

    /** 

await bot.reply(message,{
                text: 'Here are some quick replies',
                quick_replies: [
                    {
                        title: 'Foo',
                        payload: 'foo',
                    },
                    {
                        title: 'Bar',
                        payload: 'bar',
                    }
                ]
            });
        });

        let typing = new BotkitConversation('typing', controller);

        typing.say('I am going to type for a while now...');
        typing.addAction('typing');
    
        // start the typing indicator
        typing.addMessage({type: 'typing'}, 'typing');
        // trigger a gotoThread, which gives us an opportunity to delay the next message
        typing.addAction('next_thread','typing');
    
        typing.addMessage('typed!','next_thread');
    
       // use the before handler to delay the next message 
        typing.before('next_thread',  async() => {
            return new Promise((resolve, reject) => {
                // simulate some long running process
                setTimeout(resolve, 3000);

// Return an error to Slack
            bot.dialogError([
                {
                    "name": "field1",
                    "error": "there was an error in field1"
                }
            ])
        });

        controller.on('dialog_cancellation', async (bot, message) => {
            await bot.reply(message, 'Got a dialog cancellation');
        });


        const dialog = new BotkitConversation('slack_buttons', controller);

        dialog.ask({
            text: 'Click one of these ATTACHMENT BUTTONS',
            attachments: [
                {
                    title: 'This is an attachment',
                    text: 'It has some buttons',
                    callback_id: '123',
                    actions: [
                        {
                            name: 'buttona',
                            type:  'button',
                            text: 'Click this',
                            value: 'Clicked this',                                
                        },
                        {

module.exports = function(controller) {

    const dialog = new BotkitConversation('HELPDIALOG', controller);

    dialog.ask('What can I help with?', [], 'subject');
    dialog.say('HRRM! What do I know about {{vars.subject}}?');
    dialog.addAction('display_results');

    dialog.before('display_results', async(convo, bot) => {
        convo.setVar('results', 'KNOWLEDGE BASE EMPTY');
    });

    dialog.addMessage('Here is what I know: {{vars.results}}', 'display_results');

    controller.addDialog(dialog);

    // hear the word help, and interrupt whatever is happening to handle it first.
    controller.interrupts(async(message) => { return message.intent==='help' }, 'message', async(bot, message) => {
        await bot.reply(message,'I heard you need help more than anything else!');

},
        async(step) => {
            // capture result of previous step
            step.values.age = step.result;

            return await step.prompt(ONBOARDING_PROMPT, 'What is your location?');
        },
        async(step) => {
            // capture result of previous step
            step.values.location = step.result;

            return await step.endDialog(step.values);
        }
    ]);

    const confirmation = new BotkitConversation(CONFIRM_DIALOG, controller);
    confirmation.say('Your name is {{vars.profile.name}}, your age is {{vars.profile.age}} and your location is {{vars.profile.location}}');
    confirmation.ask('Is that correct?', [
        {
            pattern: 'no',
            handler: async(res, convo, bot) => {
                await convo.gotoThread('try_again');
                // convo
            }
        },
        {
            default: true,
            handler: async(res, convo, bot) => {
                // noop, just continue
            }
        }
    ],{key:'confirmed'});

handler: async(res, convo, bot) => {
                await convo.gotoThread('try_again');
                // convo
            }
        },
        {
            default: true,
            handler: async(res, convo, bot) => {
                // noop, just continue
            }
        }
    ],{key:'confirmed'});
    confirmation.say('All done!');
    confirmation.addGotoDialog(START_OVER,'try_again');

    const startover = new BotkitConversation(START_OVER, controller);
    startover.say('Lets start from the top...');
    startover.addChildDialog(PROFILE_DIALOG, 'profile');
    startover.addGotoDialog(CONFIRM_DIALOG);

    /**
     * Now, define a BotkitConversation style dialog that will use the profile dialog as a child.
     */
    const onboarding = new BotkitConversation(ONBOARDING_DIALOG, controller);
    onboarding.say('Hello, human! Nice to meet you.');
    onboarding.say('Before we begin, I need to ask you some questions.');
    onboarding.addChildDialog(PROFILE_DIALOG, 'profile');
    onboarding.say('Thanks, {{vars.profile.name}}! Your onboarding has completed.');
    onboarding.addGotoDialog(CONFIRM_DIALOG);

    /**
     * Add all of our dialogs to the bot.

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

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

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

const Botkit = require('botkit');

const slackController = Botkit.slackbot({
  debug: true,
});

const slackBot = slackController.spawn({
  token: process.env.slack,
});

const dialogflowMiddleware = require('../')({
  keyFilename: process.env.dialogflow,
});

slackController.middleware.receive.use(dialogflowMiddleware.receive);
slackBot.startRTM();

/* note this uses example middlewares defined above */
slackController.hears(['hello-intent'], 'direct_message', dialogflowMiddleware.hears, function(

console.log('Error: Specify token in environment');
    process.exit(1);
}

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

var Botkit = require('botkit');
var wit = require('./src/botkit-middleware-witai')({
    token: process.env.wit,
});


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

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

controller.middleware.receive.use(wit.receive);


/* note this uses example middlewares defined above */
controller.hears(['hello'], 'direct_message,direct_mention,mention', wit.hears, function(bot, message) {
    bot.reply(message, 'Hello!');
});

name: 'ltsubdomain',
    alias: 's',
    args: 1,
    description:
      'Custom subdomain for the localtunnel.me URL. This option can only be used together with --lt.',
    type: String,
    defaultValue: null,
  },
]);

if (ops.lt === false && ops.ltsubdomain !== null) {
  console.log('error: --ltsubdomain can only be used together with --lt.');
  process.exit();
}

const controller = Botkit.facebookbot({
  debug: true,
  log: true,
  access_token: process.env.page_token,
  verify_token: process.env.verify_token,
  app_secret: process.env.app_secret,
  validate_requests: true, // Refuse any requests that don't provide the app_secret specified
});

const dialogflow = require('../')({
  keyFilename: process.env.dialogflow,
});

controller.middleware.receive.use(dialogflow.receive);

const bot = controller.spawn({});