botkit/lib/conversation.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const dialogWrapper_1 = require("./dialogWrapper");
const botbuilder_1 = require("botbuilder");
const botbuilder_dialogs_1 = require("botbuilder-dialogs");
const mustache = require("mustache");
const Debug = require("debug");
const debug = Debug('botkit:conversation');
/**
 * An extension on the [BotBuilder Dialog Class](https://docs.microsoft.com/en-us/javascript/api/botbuilder-dialogs/dialog?view=botbuilder-ts-latest) that provides a Botkit-friendly interface for
 * defining and interacting with multi-message dialogs. Dialogs can be constructed using `say()`, `ask()` and other helper methods.
 *
 * ```javascript
 * // define the structure of your dialog...
 * const convo = new BotkitConversation('foo', controller);
 * convo.say('Hello!');
 * convo.ask('What is your name?', async(answer, convo, bot) => {
 *      await bot.say('Your name is ' + answer);
 * });
 * controller.dialogSet.add(convo);
 *
 * // later on, trigger this dialog by its id
 * controller.on('event', async(bot, message) => {
 *  await bot.beginDialog('foo');
 * })
 * ```
 */
class BotkitConversation extends botbuilder_dialogs_1.Dialog {
    /**
     * Create a new BotkitConversation object
     * @param dialogId A unique identifier for this dialog, used to later trigger this dialog
     * @param controller A pointer to the main Botkit controller
     */
    constructor(dialogId, controller) {
        super(dialogId);
        this._beforeHooks = {};
        this._afterHooks = [];
        this._changeHooks = {};
        this.script = {};
        this._controller = controller;
        // Make sure there is a prompt we can use.
        // TODO: maybe this ends up being managed by Botkit
        this._prompt = this.id + '_default_prompt';
        this._controller.dialogSet.add(new botbuilder_dialogs_1.ActivityPrompt(this._prompt, (prompt) => Promise.resolve(prompt.recognized.succeeded === true)));
        return this;
    }
    /**
     * Add a non-interactive message to the default thread.
     * Messages added with `say()` and `addMessage()` will _not_ wait for a response, will be sent one after another without a pause.
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     *
     * ```javascript
     * let conversation = new BotkitConversation('welcome', controller);
     * conversation.say('Hello! Welcome to my app.');
     * conversation.say('Let us get started...');
     * ```
     *
     * @param message Message template to be sent
     */
    say(message) {
        this.addMessage(message, 'default');
        return this;
    }
    /**
     * An an action to the conversation timeline. This can be used to go to switch threads or end the dialog.
     *
     * When provided the name of another thread in the conversation, this will cause the bot to go immediately
     * to that thread.
     *
     * Otherwise, use one of the following keywords:
     * * `stop`
     * * `repeat`
     * * `complete`
     * * `timeout`
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     *
     * ```javascript
     *
     * // go to a thread called "next_thread"
     * convo.addAction('next_thread');
     *
     * // end the conversation and mark as successful
     * convo.addAction('complete');
     * ```
     * @param action An action or thread name
     * @param thread_name The name of the thread to which this action is added.  Defaults to `default`
     */
    addAction(action, thread_name = 'default') {
        this.addMessage({ action: action }, thread_name);
        return this;
    }
    /**
     * Cause the dialog to call a child dialog, wait for it to complete,
     * then store the results in a variable and resume the parent dialog.
     * Use this to [combine multiple dialogs into bigger interactions.](../conversations.md#composing-dialogs)
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     * ```javascript
     * // define a profile collection dialog
     * let profileDialog = new BotkitConversation('PROFILE_DIALOG', controller);
     * profileDialog.ask('What is your name?', async(res, convo, bot) => {}, {key: 'name'});
     * profileDialog.ask('What is your age?', async(res, convo, bot) => {}, {key: 'age'});
     * profileDialog.ask('What is your location?', async(res, convo, bot) => {}, {key: 'location'});
     * controller.addDialog(profileDialog);
     *
     * let onboard = new BotkitConversation('ONBOARDING', controller);
     * onboard.say('Hello! It is time to collect your profile data.');
     * onboard.addChildDialog('PROFILE_DIALOG', 'profile');
     * onboard.say('Hello, {{vars.profile.name}}! Onboarding is complete.');
     * ```
     *
     * @param dialog_id the id of another dialog
     * @param key_name the variable name in which to store the results of the child dialog. if not provided, defaults to dialog_id.
     * @param thread_name the name of a thread to which this call should be added. defaults to 'default'
     */
    addChildDialog(dialog_id, key_name, thread_name = 'default') {
        this.addQuestion({
            action: 'beginDialog',
            execute: {
                script: dialog_id
            }
        }, [], { key: key_name || dialog_id }, thread_name);
        return this;
    }
    /**
     * Cause the current dialog to handoff to another dialog.
     * The parent dialog will not resume when the child dialog completes. However, the afterDialog event will not fire for the parent dialog until all child dialogs complete.
     * Use this to [combine multiple dialogs into bigger interactions.](../conversations.md#composing-dialogs)
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     * ```javascript
     * let parent = new BotkitConversation('parent', controller);
     * let child = new BotkitConversation('child', controller);
     * parent.say('Moving on....');
     * parent.addGotoDialog('child');
     * ```
     *
     * @param dialog_id the id of another dialog
     * @param thread_name the name of a thread to which this call should be added. defaults to 'default'
     */
    addGotoDialog(dialog_id, thread_name = 'default') {
        this.addMessage({
            action: 'execute_script',
            execute: {
                script: dialog_id
            }
        }, thread_name);
        return this;
    }
    /**
     * Add a message template to a specific thread.
     * Messages added with `say()` and `addMessage()` will be sent one after another without a pause.
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     * ```javascript
     * let conversation = new BotkitConversation('welcome', controller);
     * conversation.say('Hello! Welcome to my app.');
     * conversation.say('Let us get started...');
     * // pass in a message with an action that will cause gotoThread to be called...
     * conversation.addAction('continuation');
     *
     * conversation.addMessage('This is a different thread completely', 'continuation');
     * ```
     *
     * @param message Message template to be sent
     * @param thread_name Name of thread to which message will be added
     */
    addMessage(message, thread_name) {
        if (!thread_name) {
            thread_name = 'default';
        }
        if (!this.script[thread_name]) {
            this.script[thread_name] = [];
        }
        if (typeof (message) === 'string') {
            message = { text: [message] };
        }
        this.script[thread_name].push(message);
        return this;
    }
    /**
     * Add a question to the default thread.
     * In addition to a message template, receives either a single handler function to call when an answer is provided,
     * or an array of handlers paired with trigger patterns. When providing multiple conditions to test, developers may also provide a
     * handler marked as the default choice.
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     * ```javascript
     * // ask a question, handle the response with a function
     * convo.ask('What is your name?', async(response, convo, bot, full_message) => {
     *  await bot.say('Oh your name is ' + response);
     * }, {key: 'name'});
     *
     * // ask a question, evaluate answer, take conditional action based on response
     * convo.ask('Do you want to eat a taco?', [
     *  {
     *      pattern: 'yes',
     *      type: 'string',
     *      handler: async(response_text, convo, bot, full_message) => {
     *          return await convo.gotoThread('yes_taco');
     *      }
     *  },
     *  {
     *      pattern: 'no',
     *      type: 'string',
     *      handler: async(response_text, convo, bot, full_message) => {
     *          return await convo.gotoThread('no_taco');
     *      }
     *   },
     *   {
     *       default: true,
     *       handler: async(response_text, convo, bot, full_message) => {
     *           await bot.say('I do not understand your response!');
     *           // start over!
     *           return await convo.repeat();
     *       }
     *   }
     * ], {key: 'tacos'});
     * ```
     *
     * @param message a message that will be used as the prompt
     * @param handlers one or more handler functions defining possible conditional actions based on the response to the question.
     * @param key name of variable to store response in.
     */
    ask(message, handlers, key) {
        this.addQuestion(message, handlers, key, 'default');
        return this;
    }
    /**
     * Identical to [ask()](#ask), but accepts the name of a thread to which the question is added.
     *
     * [Learn more about building conversations →](../conversations.md#build-a-conversation)
     * @param message A message that will be used as the prompt
     * @param handlers One or more handler functions defining possible conditional actions based on the response to the question
     * @param key Name of variable to store response in.
     * @param thread_name Name of thread to which message will be added
     */
    addQuestion(message, handlers, key, thread_name) {
        if (!thread_name) {
            thread_name = 'default';
        }
        if (!this.script[thread_name]) {
            this.script[thread_name] = [];
        }
        if (typeof (message) === 'string') {
            message = { text: [message] };
        }
        message.collect = {};
        if (key) {
            message.collect = {
                key: typeof (key) === 'string' ? key : key.key
            };
        }
        if (Array.isArray(handlers)) {
            message.collect.options = handlers;
        }
        else if (typeof (handlers) === 'function') {
            message.collect.options = [
                {
                    default: true,
                    handler: handlers
                }
            ];
        }
        else {
            throw new Error('Unsupported handlers type: ' + typeof (handlers));
        }
        // ensure all options have a type field
        message.collect.options.forEach((o) => { if (!o.type) {
            o.type = 'string';
        } });
        this.script[thread_name].push(message);
        // add a null message where the handlers for the previous message will fire.
        this.script[thread_name].push({ action: 'next' });
        return this;
    }
    /**
     * Register a handler function that will fire before a given thread begins.
     * Use this hook to set variables, call APIs, or change the flow of the conversation using `convo.gotoThread`
     *
     * ```javascript
     * convo.addMessage('This is the foo thread: var == {{vars.foo}}', 'foo');
     * convo.before('foo', async(convo, bot) => {
     *  // set a variable here that can be used in the message template
     *  convo.setVar('foo','THIS IS FOO');
     *
     * });
     * ```
     *
     * @param thread_name A valid thread defined in this conversation
     * @param handler A handler function in the form async(convo, bot) => { ... }
     */
    before(thread_name, handler) {
        if (!this._beforeHooks[thread_name]) {
            this._beforeHooks[thread_name] = [];
        }
        this._beforeHooks[thread_name].push(handler);
    }
    /**
     * This private method is called before a thread begins, and causes any bound handler functions to be executed.
     * @param thread_name the thread about to begin
     * @param dc the current DialogContext
     * @param step the current step object
     */
    runBefore(thread_name, dc, step) {
        return __awaiter(this, void 0, void 0, function* () {
            debug('Before:', this.id, thread_name);
            if (this._beforeHooks[thread_name]) {
                // spawn a bot instance so devs can use API or other stuff as necessary
                const bot = yield this._controller.spawn(dc);
                // create a convo controller object
                const convo = new dialogWrapper_1.BotkitDialogWrapper(dc, step);
                for (let h = 0; h < this._beforeHooks[thread_name].length; h++) {
                    const handler = this._beforeHooks[thread_name][h];
                    yield handler.call(this, convo, bot);
                }
            }
        });
    }
    /**
     * Bind a function to run after the dialog has completed.
     * The first parameter to the handler will include a hash of all variables set and values collected from the user during the conversation.
     * The second parameter to the handler is a BotWorker object that can be used to start new dialogs or take other actions.
     *
     * [Learn more about handling end of conversation](../conversations.md#handling-end-of-conversation)
     * ```javascript
     * let convo = new BotkitConversation(MY_CONVO, controller);
     * convo.ask('What is your name?', [], 'name');
     * convo.ask('What is your age?', [], 'age');
     * convo.ask('What is your favorite color?', [], 'color');
     * convo.after(async(results, bot) => {
     *
     *      // handle results.name, results.age, results.color
     *
     * });
     * controller.addDialog(convo);
     * ```
     *
     * @param handler in the form async(results, bot) { ... }
     */
    after(handler) {
        this._afterHooks.push(handler);
    }
    /**
     * This private method is called at the end of the conversation, and causes any bound handler functions to be executed.
     * @param context the current dialog context
     * @param results an object containing the final results of the dialog
     */
    runAfter(context, results) {
        return __awaiter(this, void 0, void 0, function* () {
            debug('After:', this.id);
            if (this._afterHooks.length) {
                const bot = yield this._controller.spawn(context);
                for (let h = 0; h < this._afterHooks.length; h++) {
                    const handler = this._afterHooks[h];
                    yield handler.call(this, results, bot);
                }
            }
        });
    }
    /**
     * Bind a function to run whenever a user answers a specific question.  Can be used to validate input and take conditional actions.
     *
     * ```javascript
     * convo.ask('What is your name?', [], 'name');
     * convo.onChange('name', async(response, convo, bot) => {
     *
     *  // user changed their name!
     *  // do something...
     *
     * });
     * ```
     * @param variable name of the variable to watch for changes
     * @param handler a handler function that will fire whenever a user's response is used to change the value of the watched variable
     */
    onChange(variable, handler) {
        if (!this._changeHooks[variable]) {
            this._changeHooks[variable] = [];
        }
        this._changeHooks[variable].push(handler);
    }
    /**
     * This private method is responsible for firing any bound onChange handlers when a variable changes
     * @param variable the name of the variable that is changing
     * @param value the new value of the variable
     * @param dc the current DialogContext
     * @param step the current step object
     */
    runOnChange(variable, value, dc, step) {
        return __awaiter(this, void 0, void 0, function* () {
            debug('OnChange:', this.id, variable);
            if (this._changeHooks[variable] && this._changeHooks[variable].length) {
                // spawn a bot instance so devs can use API or other stuff as necessary
                const bot = yield this._controller.spawn(dc);
                // create a convo controller object
                const convo = new dialogWrapper_1.BotkitDialogWrapper(dc, step);
                for (let h = 0; h < this._changeHooks[variable].length; h++) {
                    const handler = this._changeHooks[variable][h];
                    yield handler.call(this, value, convo, bot);
                }
            }
        });
    }
    /**
     * Called automatically when a dialog begins. Do not call this directly!
     * @ignore
     * @param dc the current DialogContext
     * @param options an object containing initialization parameters passed to the dialog. may include `thread` which will cause the dialog to begin with that thread instead of the `default` thread.
     */
    beginDialog(dc, options) {
        return __awaiter(this, void 0, void 0, function* () {
            // Initialize the state
            const state = dc.activeDialog.state;
            state.options = options || {};
            state.values = Object.assign({}, options);
            // Run the first step
            return yield this.runStep(dc, 0, state.options.thread || 'default', botbuilder_dialogs_1.DialogReason.beginCalled);
        });
    }
    /**
     * Called automatically when an already active dialog is continued. Do not call this directly!
     * @ignore
     * @param dc the current DialogContext
     */
    continueDialog(dc) {
        return __awaiter(this, void 0, void 0, function* () {
            // Don't do anything for non-message activities
            if (dc.context.activity.type !== botbuilder_1.ActivityTypes.Message) {
                return botbuilder_dialogs_1.Dialog.EndOfTurn;
            }
            // Run next step with the message text as the result.
            return yield this.resumeDialog(dc, botbuilder_dialogs_1.DialogReason.continueCalled, dc.context.activity);
        });
    }
    /**
     * Called automatically when a dialog moves forward a step. Do not call this directly!
     * @ignore
     * @param dc The current DialogContext
     * @param reason Reason for resuming the dialog
     * @param result Result of previous step
     */
    resumeDialog(dc, reason, result) {
        return __awaiter(this, void 0, void 0, function* () {
            // Increment step index and run step
            if (dc.activeDialog) {
                const state = dc.activeDialog.state;
                return yield this.runStep(dc, state.stepIndex + 1, state.thread || 'default', reason, result);
            }
            else {
                return botbuilder_dialogs_1.Dialog.EndOfTurn;
            }
        });
    }
    /**
     * Called automatically to process the turn, interpret the script, and take any necessary actions based on that script. Do not call this directly!
     * @ignore
     * @param dc The current dialog context
     * @param step The current step object
     */
    onStep(dc, step) {
        return __awaiter(this, void 0, void 0, function* () {
            // Let's interpret the current line of the script.
            const thread = this.script[step.thread];
            if (!thread) {
                throw new Error(`Thread '${step.thread}' not found, did you add any messages to it?`);
            }
            // Capture the previous step value if there previous line included a prompt
            const previous = (step.index >= 1) ? thread[step.index - 1] : null;
            if (step.result && previous && previous.collect) {
                if (previous.collect.key) {
                    // capture before values
                    const index = step.index;
                    const thread_name = step.thread;
                    // capture the user input value into the array
                    if (step.values[previous.collect.key] && previous.collect.multiple) {
                        step.values[previous.collect.key] = [step.values[previous.collect.key], step.result].join('\n');
                    }
                    else {
                        step.values[previous.collect.key] = step.result;
                    }
                    // run onChange handlers
                    yield this.runOnChange(previous.collect.key, step.result, dc, step);
                    // did we just change threads? if so, restart this turn
                    if (index !== step.index || thread_name !== step.thread) {
                        return yield this.runStep(dc, step.index, step.thread, botbuilder_dialogs_1.DialogReason.nextCalled);
                    }
                }
                // handle conditions of previous step
                if (previous.collect.options) {
                    const paths = previous.collect.options.filter((option) => { return !option.default === true; });
                    const default_path = previous.collect.options.filter((option) => { return option.default === true; })[0];
                    let path = null;
                    for (let p = 0; p < paths.length; p++) {
                        const condition = paths[p];
                        let test;
                        if (condition.type === 'string') {
                            test = new RegExp(condition.pattern, 'i');
                        }
                        else if (condition.type === 'regex') {
                            test = new RegExp(condition.pattern, 'i');
                        }
                        // TODO: Allow functions to be passed in as patterns
                        // ie async(test) => Promise<boolean>
                        if (step.result && typeof (step.result) === 'string' && step.result.match(test)) {
                            path = condition;
                            break;
                        }
                    }
                    // take default path if one is set
                    if (!path) {
                        path = default_path;
                    }
                    if (path) {
                        if (path.action !== 'wait' && previous.collect && previous.collect.multiple) {
                            // TODO: remove the final line of input
                            // since this would represent the "end" message and probably not part of the input
                        }
                        const res = yield this.handleAction(path, dc, step);
                        if (res !== false) {
                            return res;
                        }
                    }
                }
            }
            // was the dialog canceled during the last action?
            if (!dc.activeDialog) {
                return yield this.end(dc);
            }
            // Handle the current step
            if (step.index < thread.length) {
                const line = thread[step.index];
                // If a prompt is defined in the script, use dc.prompt to call it.
                // This prompt must be a valid dialog defined somewhere in your code!
                if (line.collect && line.action !== 'beginDialog') {
                    try {
                        return yield dc.prompt(this._prompt, yield this.makeOutgoing(dc, line, step.values));
                    }
                    catch (err) {
                        console.error(err);
                        yield dc.context.sendActivity(`Failed to start prompt ${this._prompt}`);
                        return yield step.next();
                    }
                    // If there's nothing but text, send it!
                    // This could be extended to include cards and other activity attributes.
                }
                else {
                    // if there is text, attachments, or any channel data fields at all...
                    if (line.type || line.text || line.attachments || line.attachment || line.blocks || (line.channelData && Object.keys(line.channelData).length)) {
                        yield dc.context.sendActivity(yield this.makeOutgoing(dc, line, step.values));
                    }
                    else if (!line.action) {
                        console.error('Dialog contains invalid message', line);
                    }
                    if (line.action) {
                        const res = yield this.handleAction(line, dc, step);
                        if (res !== false) {
                            return res;
                        }
                    }
                    return yield step.next();
                }
            }
            else {
                // End of script so just return to parent
                return yield this.end(dc);
            }
        });
    }
    /**
     * Run a dialog step, based on the index and thread_name passed in.
     * @param dc The current DialogContext
     * @param index The index of the current step
     * @param thread_name The name of the current thread
     * @param reason The reason given for running this step
     * @param result The result of the previous turn if any
     */
    runStep(dc, index, thread_name, reason, result) {
        return __awaiter(this, void 0, void 0, function* () {
            // Update the step index
            const state = dc.activeDialog.state;
            state.stepIndex = index;
            state.thread = thread_name;
            // Create step context
            const nextCalled = false;
            const step = {
                index: index,
                threadLength: this.script[thread_name].length,
                thread: thread_name,
                state: state,
                options: state.options,
                reason: reason,
                result: result && result.text ? result.text : result,
                resultObject: result,
                values: state.values,
                next: (stepResult) => __awaiter(this, void 0, void 0, function* () {
                    if (nextCalled) {
                        throw new Error(`ScriptedStepContext.next(): method already called for dialog and step '${this.id}[${index}]'.`);
                    }
                    return yield this.resumeDialog(dc, botbuilder_dialogs_1.DialogReason.nextCalled, stepResult);
                })
            };
            // did we just start a new thread?
            // if so, run the before stuff.
            if (index === 0) {
                yield this.runBefore(step.thread, dc, step);
                // did we just change threads? if so, restart
                if (index !== step.index || thread_name !== step.thread) {
                    return yield this.runStep(dc, step.index, step.thread, botbuilder_dialogs_1.DialogReason.nextCalled); // , step.values);
                }
            }
            // Execute step
            const res = yield this.onStep(dc, step);
            return res;
        });
    }
    /**
     * Automatically called when the the dialog ends and causes any handlers bound using `after()` to fire. Do not call this directly!
     * @ignore
     * @param dc The current DialogContext
     * @param value The final value collected by the dialog.
     */
    end(dc) {
        return __awaiter(this, void 0, void 0, function* () {
            // TODO: may have to move these around
            // shallow copy todo: may need deep copy
            // protect against canceled dialog.
            if (dc.activeDialog && dc.activeDialog.state) {
                const result = Object.assign({}, dc.activeDialog.state.values);
                yield dc.endDialog(result);
                yield this.runAfter(dc, result);
            }
            else {
                yield dc.endDialog();
            }
            return botbuilder_dialogs_1.DialogTurnStatus.complete;
        });
    }
    /**
     * Translates a line from the dialog script into an Activity. Responsible for doing token replacement.
     * @param line a message template from the script
     * @param vars an object containing key/value pairs used to do token replacement on fields in the message template
     */
    makeOutgoing(dc, line, vars) {
        return __awaiter(this, void 0, void 0, function* () {
            let outgoing;
            let text = '';
            // if the text is just a string, use it.
            // otherwise, if it is an array, pick a random element
            if (line.text && typeof (line.text) === 'string') {
                text = line.text;
                // If text is a function, call the function to get the actual text value.
            }
            else if (line.text && typeof (line.text) === 'function') {
                text = yield line.text(line, vars);
            }
            else if (Array.isArray(line.text)) {
                text = line.text[Math.floor(Math.random() * line.text.length)];
            }
            /*******************************************************************************************************************/
            // use Bot Framework's message factory to construct the initial object.
            if (line.quick_replies && typeof (line.quick_replies) !== 'function') {
                outgoing = botbuilder_1.MessageFactory.suggestedActions(line.quick_replies.map((reply) => { return { type: botbuilder_1.ActionTypes.PostBack, title: reply.title, text: reply.payload, displayText: reply.title, value: reply.payload }; }), text);
            }
            else {
                outgoing = botbuilder_1.MessageFactory.text(text);
            }
            outgoing.channelData = outgoing.channelData ? outgoing.channelData : {};
            if (line.attachmentLayout) {
                outgoing.attachmentLayout = line.attachmentLayout;
            }
            /*******************************************************************************************************************/
            // allow dynamic generation of quick replies and/or attachments
            if (typeof (line.quick_replies) === 'function') {
                // set both formats of quick replies
                outgoing.channelData.quick_replies = yield line.quick_replies(line, vars);
                outgoing.suggestedActions = { actions: outgoing.channelData.quick_replies.map((reply) => { return { type: botbuilder_1.ActionTypes.PostBack, title: reply.title, text: reply.payload, displayText: reply.title, value: reply.payload }; }) };
            }
            if (typeof (line.attachment) === 'function') {
                outgoing.channelData.attachment = yield line.attachment(line, vars);
            }
            if (typeof (line.attachments) === 'function') {
                // set both locations for attachments
                outgoing.attachments = outgoing.channelData.attachments = yield line.attachments(line, vars);
            }
            if (typeof (line.blocks) === 'function') {
                outgoing.channelData.blocks = yield line.blocks(line, vars);
            }
            /*******************************************************************************************************************/
            // Map some fields into the appropriate places for processing by Botkit/ Bot Framework
            // Quick replies are used by Facebook and Web adapters, but in a different way than they are for Bot Framework.
            // In order to make this as easy as possible, copy these fields for the developer into channelData.
            if (line.quick_replies && typeof (line.quick_replies) !== 'function') {
                outgoing.channelData.quick_replies = JSON.parse(JSON.stringify(line.quick_replies));
            }
            // Similarly, attachment and blocks fields are platform specific.
            // handle slack Block attachments
            if (line.blocks && typeof (line.blocks) !== 'function') {
                outgoing.channelData.blocks = JSON.parse(JSON.stringify(line.blocks));
            }
            // handle facebook attachments.
            if (line.attachment && typeof (line.attachment) !== 'function') {
                outgoing.channelData.attachment = JSON.parse(JSON.stringify(line.attachment));
            }
            // set the type
            if (line.type) {
                outgoing.type = JSON.parse(JSON.stringify(line.type));
            }
            // copy all the values in channelData fields
            if (line.channelData && Object.keys(line.channelData).length > 0) {
                const channelDataParsed = this.parseTemplatesRecursive(JSON.parse(JSON.stringify(line.channelData)), vars);
                outgoing.channelData = Object.assign(Object.assign({}, outgoing.channelData), channelDataParsed);
            }
            /*******************************************************************************************************************/
            // Handle template token replacements
            if (outgoing.text) {
                outgoing.text = mustache.render(outgoing.text, { vars: vars });
            }
            // process templates in native botframework attachments and/or slack attachments
            if (line.attachments && typeof (line.attachments) !== 'function') {
                outgoing.attachments = this.parseTemplatesRecursive(JSON.parse(JSON.stringify(line.attachments)), vars);
            }
            // process templates in slack attachments in channelData
            if (outgoing.channelData.attachments) {
                outgoing.channelData.attachments = this.parseTemplatesRecursive(outgoing.channelData.attachments, vars);
            }
            if (outgoing.channelData.blocks) {
                outgoing.channelData.blocks = this.parseTemplatesRecursive(outgoing.channelData.blocks, vars);
            }
            // process templates in facebook attachments
            if (outgoing.channelData.attachment) {
                outgoing.channelData.attachment = this.parseTemplatesRecursive(outgoing.channelData.attachment, vars);
            }
            // process templates in quick replies
            if (outgoing.channelData.quick_replies) {
                outgoing.channelData.quick_replies = this.parseTemplatesRecursive(outgoing.channelData.quick_replies, vars);
            }
            // process templates in quick replies
            if (outgoing.suggestedActions) {
                outgoing.suggestedActions = this.parseTemplatesRecursive(outgoing.suggestedActions, vars);
            }
            return new Promise((resolve, reject) => {
                // run the outgoing message through the Botkit send middleware
                this._controller.spawn(dc).then((bot) => {
                    this._controller.middleware.send.run(bot, outgoing, (err, bot, outgoing) => {
                        if (err) {
                            reject(err);
                        }
                        else {
                            resolve(outgoing);
                        }
                    });
                }).catch(reject);
            });
        });
    }
    /**
     * Responsible for doing token replacements recursively in attachments and other multi-field properties of the message.
     * @param attachments some object or array containing values for which token replacements should be made.
     * @param vars an object defining key/value pairs used for the token replacements
     */
    parseTemplatesRecursive(attachments, vars) {
        if (attachments && attachments.length) {
            for (let a = 0; a < attachments.length; a++) {
                for (const key in attachments[a]) {
                    if (typeof (attachments[a][key]) === 'string') {
                        attachments[a][key] = mustache.render(attachments[a][key], { vars: vars });
                    }
                    else {
                        attachments[a][key] = this.parseTemplatesRecursive(attachments[a][key], vars);
                    }
                }
            }
        }
        else {
            for (const x in attachments) {
                if (typeof (attachments[x]) === 'string') {
                    attachments[x] = mustache.render(attachments[x], { vars: vars });
                }
                else {
                    attachments[x] = this.parseTemplatesRecursive(attachments[x], vars);
                }
            }
        }
        return attachments;
    }
    /**
     * Handle the scripted "gotothread" action - requires an additional call to runStep.
     * @param thread The name of the thread to jump to
     * @param dc The current DialogContext
     * @param step The current step object
     */
    gotoThreadAction(thread, dc, step) {
        return __awaiter(this, void 0, void 0, function* () {
            step.thread = thread;
            step.index = 0;
            return yield this.runStep(dc, step.index, step.thread, botbuilder_dialogs_1.DialogReason.nextCalled, step.values);
        });
    }
    /**
     * Accepts a Botkit script action, and performs that action
     * @param path A conditional path in the form {action: 'some action', handler?: some handler function, maybe_other_fields}
     * @param dc The current DialogContext
     * @param step The current stpe object
     */
    handleAction(path, dc, step) {
        return __awaiter(this, void 0, void 0, function* () {
            let worker = null;
            if (path.handler) {
                const index = step.index;
                const thread_name = step.thread;
                const result = step.result;
                const response = result == null ? null : (result.text || (typeof (result) === 'string' ? result : null));
                // spawn a bot instance so devs can use API or other stuff as necessary
                const bot = yield this._controller.spawn(dc);
                // create a convo controller object
                const convo = new dialogWrapper_1.BotkitDialogWrapper(dc, step);
                const activedialog = dc.activeDialog.id;
                yield path.handler.call(this, response, convo, bot, dc.context.turnState.get('botkitMessage') || dc.context.activity);
                if (!dc.activeDialog) {
                    return false;
                }
                // did we change dialogs? if so, return an endofturn because the new dialog has taken over.
                if (activedialog !== dc.activeDialog.id) {
                    return botbuilder_dialogs_1.Dialog.EndOfTurn;
                }
                // did we just change threads? if so, restart this turn
                if (index !== step.index || thread_name !== step.thread) {
                    return yield this.runStep(dc, step.index, step.thread, botbuilder_dialogs_1.DialogReason.nextCalled, null);
                }
                return false;
            }
            switch (path.action) {
                case 'next':
                    // noop
                    break;
                case 'complete':
                    step.values._status = 'completed';
                    return yield this.end(dc);
                case 'stop':
                    step.values._status = 'canceled';
                    return yield this.end(dc);
                case 'timeout':
                    step.values._status = 'timeout';
                    return yield this.end(dc);
                case 'execute_script':
                    worker = yield this._controller.spawn(dc);
                    yield worker.replaceDialog(path.execute.script, Object.assign({ thread: path.execute.thread }, step.values));
                    return { status: botbuilder_dialogs_1.DialogTurnStatus.waiting };
                case 'beginDialog':
                    worker = yield this._controller.spawn(dc);
                    yield worker.beginDialog(path.execute.script, Object.assign({ thread: path.execute.thread }, step.values));
                    return { status: botbuilder_dialogs_1.DialogTurnStatus.waiting };
                case 'repeat':
                    return yield this.runStep(dc, step.index - 1, step.thread, botbuilder_dialogs_1.DialogReason.nextCalled);
                case 'wait':
                    // reset the state so we're still on this step.
                    step.state.stepIndex = step.index - 1;
                    // send a waiting status
                    return { status: botbuilder_dialogs_1.DialogTurnStatus.waiting };
                default:
                    // the default behavior for unknown action in botkit is to gotothread
                    if (this.script[path.action]) {
                        return yield this.gotoThreadAction(path.action, dc, step);
                    }
                    console.warn('NOT SURE WHAT TO DO WITH THIS!!', path);
                    break;
            }
            return false;
        });
    }
}
exports.BotkitConversation = BotkitConversation;
//# sourceMappingURL=conversation.js.map