wingbot 3.39.0-alpha.2 → 3.39.0-alpha.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.39.0-alpha.2",
+  "version": "3.39.0-alpha.3",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {

package/plugins/ai.wingbot.slotsContinue/plugin.js

@@ -0,0 +1,44 @@
+const { StepState, StepType, getNextStep } = require('../../src/utils/slots');
+const { vars } = require('../../src/utils/stateVariables');
+
+/** @typedef {import('../../src/Router').Resolver} Resolver */
+/** @typedef {import('../../src/Responder')} Responder */
+/** @typedef {import('../../src/utils/slots').SlotBotState} SlotBotState */
+/** @typedef {import('../../src/utils/slots').SlotsResolver} SlotsResolver */
+/** @typedef {import('../../src/utils/slots').SlotsRequest} SlotsRequest */
+
+/**
+ * @returns {SlotsResolver}
+ */
+function slotContinue () {
+
+    /**
+     * @param {SlotsRequest} req
+     * @param {Responder} res
+     * @param {Function} postBack
+     * @returns {Promise}
+     */
+    async function slotContinuePlugin (req, res, postBack) {
+        const state = { ...req.state, ...res.newState };
+
+        const { _slotStep: step } = state;
+        let { _slotState: slotState } = state;
+
+        if (!step || !slotState) {
+            const msg = 'ERROR: slot filling was not initialized (use the "continue" plugin after the "initialize")';
+            res.text(msg);
+            throw new Error(msg);
+        }
+        slotState = slotState.map((s) => (s.e === step.entity
+            ? { ...s, s: StepState.FILLED }
+            : s));
+
+        res.setState({ _slotState: slotState });
+
+        return getNextStep(req, res, postBack);
+    }
+
+    return slotContinuePlugin;
+}
+
+module.exports = slotContinue;

package/plugins/ai.wingbot.slotsRegister/plugin.js

@@ -0,0 +1,89 @@
+const { webalize } = require('webalize');
+const { ai } = require('../../src/Ai');
+const Router = require('../../src/Router');
+const { StepState, StepType, getNextStep } = require('../../src/utils/slots');
+const { vars } = require('../../src/utils/stateVariables');
+
+/** @typedef {import('../../src/utils/slots').SlotsResolver} SlotsResolver */
+/** @typedef {import('../../src/utils/slots').SlotPluginConfig} SlotPluginConfig */
+/** @typedef {import('../../src/utils/slots').SlotBotState} SlotBotState */
+/** @typedef {import('../../src/utils/slots').SlotState} SlotState */
+
+/**
+ *
+ * @param {SlotPluginConfig} params
+ * @returns {Router<SlotBotState>}
+ */
+function slotsRegister ({
+    steps = [],
+    doneAction,
+    intents = ''
+}) {
+
+    const useIntents = intents.split(',')
+        .map((i) => i.trim());
+
+    /** @type {Router<SlotBotState>} */
+    const bot = new Router();
+
+    const setEntities = [];
+
+    /** @type {SlotsResolver} */
+    const handler = async (req, res, postBack) => {
+        // offer rooms or (does'nt matter)
+
+        /** @type {SlotState[]} */
+        const slotState = steps.map((step) => {
+            const entity = step.entity.replace(/^@/, '');
+            const entities = req.entities.filter((e) => e.entity === entity)
+                .map((e) => e.value);
+
+            if (entities.length === 0) {
+                return {
+                    e: step.entity,
+                    s: step.type === StepType.ADDITIONAL
+                        ? StepState.FILLED
+                        : StepState.INITIALIZED
+                };
+            }
+
+            if (step.type === StepType.MULTI) {
+                setEntities.push(vars.dialogContext(`+${entity}`, entities, true));
+            } else {
+                setEntities.push(vars.dialogContext(step.entity, entities[0], true));
+            }
+
+            return {
+                e: step.entity,
+                s: step.validateAction ? StepState.FILLED : StepState.VALID
+            };
+        });
+
+        res.setState({
+            _slotState: slotState,
+            _slotSteps: steps,
+            _slotDone: doneAction,
+            ...Object.fromEntries(
+                steps.map(({ entity, type }) => (type === StepType.MULTI
+                    ? [entity.replace(/^@/, '+'), []]
+                    : [entity, null]))
+            ),
+            ...setEntities.reduce((o, r) => Object.assign(o, r), {})
+        });
+
+        return getNextStep(req, res, postBack);
+    };
+
+    bot.use(ai.global('/', useIntents), handler);
+
+    for (const step of steps) {
+        bot.use(
+            ai.global(webalize(step.entity), [...useIntents, step.entity]),
+            handler
+        );
+    }
+
+    return bot;
+}
+
+module.exports = slotsRegister;

package/plugins/plugins.json

@@ -375,6 +375,81 @@
                     "label": "Text to test (keep empty to use user input)"
                 }
             ]
+        },
+        {
+            "id": "ai.wingbot.slotsRegister",
+            "name": "Slot filling: register",
+            "description": "Sets up slot filling conversation for a list of entities",
+            "availableSince": 3.39,
+            "editable": false,
+            "isFactory": true,
+            "category": "conversation",
+            "inputs": [
+                {
+                    "type": "text",
+                    "name": "intents",
+                    "label": "Intent list (comma separated)",
+                    "validations": [
+                        { "type": "regexp", "value": "^[^\\s]+$", "message": "intent for slot filling should not be empty" }
+                    ]
+                },
+                {
+                    "type": "postback",
+                    "name": "doneAction",
+                    "label": "Continue here, when finished"
+                },
+                {
+                    "type": "array",
+                    "name": "steps",
+                    "label": "Slot",
+                    "keyPropertyName": "entity",
+                    "inputs": [
+                        {
+                            "type": "text",
+                            "name": "entity",
+                            "label": "Entity (with @)",
+                            "validations": [
+                                { "type": "regexp", "value": "^@[a-zA-Z0-9-]+$", "message": "the entity for the slot filling should be valid" }
+                            ]
+                        },
+                        {
+                            "type": "select",
+                            "name": "type",
+                            "label": "Question",
+                            "options": [
+                                { "label": "Required", "value": "req" },
+                                { "label": "Multi value", "value": "mul" },
+                                { "label": "Additional", "value": "add" }
+                            ]
+                        },
+                        {
+                            "type": "postback",
+                            "name": "askAction",
+                            "label": "Question"
+                        },
+                        {
+                            "type": "postback",
+                            "optional": true,
+                            "name": "validateAction",
+                            "label": "Validation"
+                        }
+                    ]
+                }
+            ],
+            "items": [
+            ]
+        },
+        {
+            "id": "ai.wingbot.slotsContinue",
+            "name": "Slot filling: continue",
+            "description": "move the slot filling to the next step",
+            "availableSince": 3.39,
+            "editable": false,
+            "isFactory": true,
+            "inputs": [
+            ],
+            "items": [
+            ]
         }
     ],
     "categories": [

package/src/Processor.js

@@ -1,4 +1,4 @@
-/*
+/**
  * @author David Menger
  */
 'use strict';

package/src/Tester.js

@@ -290,6 +290,14 @@ class Tester {
             || (!botAction.match(/\*/) && actionMatches(botAction, path));
     }
 
+    _actionsDebug (matchRequestActions = false) {
+        const set = new Set();
+        return this.actions
+            .filter((a) => !a.isReqAction || matchRequestActions)
+            .map((a) => (a.doNotTrack ? `(system interaction) ${a.action}` : a.action))
+            .filter((a) => !set.has(a) && set.add(a));
+    }
+
     /**
      * Checks, that request passed an interaction
      *
@@ -305,11 +313,7 @@ class Tester {
                 && this._actionMatches(action.action, path));
         let actual;
         if (!ok) {
-            const set = new Set();
-            actual = this.actions
-                .filter((a) => !a.isReqAction || matchRequestActions)
-                .map((a) => (a.doNotTrack ? `(system interaction) ${a.action}` : a.action))
-                .filter((a) => !set.has(a) && set.add(a));
+            actual = this._actionsDebug(matchRequestActions);
             assert.fail(asserts.ex('Interaction was not passed', path, actual));
         }
         return this;
@@ -419,6 +423,22 @@ class Tester {
             .intentWithEntity(this.senderId, text, intent, entity, value, score));
     }
 
+    /**
+     * Makes recognised AI request with entity
+     *
+     * @param {string} entity
+     * @param {string} [value]
+     * @param {string} [text]
+     * @param {number} [score]
+     * @returns {Promise}
+     *
+     * @memberOf Tester
+     */
+    entity (entity, value = entity, text = value, score = 1) {
+        return this.processMessage(Request
+            .intentWithEntity(this.senderId, text, `random-${Date.now()}`, entity, value, score));
+    }
+
     /**
      * Make optin call
      *
@@ -523,6 +543,27 @@ class Tester {
             .postBack(this.senderId, action, data, refAction, refData, null));
     }
 
+    /**
+     * Prints last conversation turnaround
+     *
+     * @param {boolean} [showPrivateKeys]
+     */
+    debug (showPrivateKeys = false) {
+        // eslint-disable-next-line no-console
+        console.log(
+            '\n===== actions =====\n',
+            this._actionsDebug(true),
+            '\n---- responses ----\n',
+            this.responses.map(({ messaging_type: m, recipient, ...o }) => o),
+            '\n------ state ------\n',
+            Object.fromEntries(
+                Object.entries(this.getState().state)
+                    .filter((e) => showPrivateKeys || !e[0].startsWith('_'))
+            ),
+            '\n===================\n'
+        );
+    }
+
 }
 
 module.exports = Tester;

package/src/resolvers/message.js

@@ -286,6 +286,10 @@ function message (params, context = {}) {
 
         res.text(text, sendReplies, voiceControl);
 
+        if (isLastMessage && !req.actionData()._resolverTag) {
+            res.finalMessageSent = true;
+        }
+
         return ret;
     };
 }

package/src/testTools/asserts.js

@@ -30,8 +30,8 @@ function m (text, actual = null, expected = null) {
 
 function ex (message, expected, actual) {
     const actuals = Array.isArray(actual) ? actual : [actual];
-    return `${message}\n  + expected: "${expected}"\n  - actual: ${actuals
-        .map((a) => `"${a}"`).join('\n            ')}`;
+    return `${message}\n  + expected: "${expected}"\n  - actual:   ${actuals
+        .map((a) => `"${a}"`).join('\n              ')}`;
 }
 
 function getText (response) {

package/src/utils/getUpdate.js

@@ -13,7 +13,7 @@ try {
     handlebars = { compile: (text) => () => text };
 }
 
-const ATTR_REGEX = /^([^.+]*)\.?(.+)?$/;
+const ATTR_REGEX = /^([^.]*)\.?(.+)?$/;
 const SCALAR_TYPES = ['string', 'number', 'boolean'];
 const SUBSCRIBE = '_$subscribe';
 const UNSUBSCRIBE = '_$unsubscribe';

package/src/utils/slots.js

@@ -0,0 +1,113 @@
+/**
+ * @author {David Menger}
+ */
+'use strict';
+
+const Router = require('../Router');
+const Request = require('../Request'); // eslint-disable-line no-unused-vars
+
+/** @typedef {import('../Responder')} Responder */
+
+/**
+ * @readonly
+ * @enum {string}
+ */
+const StepType = {
+    REQUIRED: 'req',
+    MULTI: 'mul',
+    ADDITIONAL: 'add'
+};
+
+/**
+ * @readonly
+ * @enum {string}
+ */
+const StepState = {
+    INITIALIZED: 'i',
+    FILLED: 'f',
+    VALID: 'v'
+};
+
+/**
+ * @typedef {object} SlotStep
+ * @prop {string} entity
+ * @prop {StepType} type
+ * @prop {string} [validateAction]
+ * @prop {string} askAction
+ */
+
+/**
+ * @typedef {object} SlotState
+ * @prop {string} e
+ * @prop {StepState} s
+ */
+
+/**
+ * @typedef {object} SlotBotState
+ * @prop {SlotState[]} _slotState
+ * @prop {SlotStep} [_slotStep]
+ * @prop {SlotStep[]} [_slotSteps]
+ * @prop {string} [_slotDone]
+ */
+
+/**
+ * @typedef {object} SlotPluginConfig
+ * @prop {SlotStep[]} steps
+ * @prop {string} doneAction
+ * @prop {string} intents
+ */
+
+/** @typedef {import('../Router').Resolver<SlotBotState>} SlotsResolver */
+/** @typedef {Request<SlotBotState>} SlotsRequest */
+
+/**
+ * @param {Request<SlotBotState>} req
+ * @param {Responder} res
+ * @param {Function} postBack
+ * @returns {Promise}
+ */
+async function getNextStep (req, res, postBack) {
+    let invalid = null;
+    const {
+        _slotState: slotState, _slotSteps: steps, _slotDone: doneAction
+    } = { ...req.state, ...res.newState };
+
+    for (const slot of slotState) {
+        const step = steps.find((s) => s.entity === slot.e);
+        if (slot.s === StepState.FILLED && step && step.validateAction) {
+            // eslint-disable-next-line
+            await postBack(step.validateAction, {}, true);
+            if (res.finalMessageSent) {
+                invalid = step;
+                break;
+            }
+            slot.s = StepState.VALID;
+        } else if (slot.s === StepState.FILLED) {
+            slot.s = StepState.VALID;
+        }
+    }
+
+    res.setState({ _slotState: slotState });
+
+    if (invalid) {
+        res.setState({ _slotStep: invalid });
+        return Router.END;
+    }
+
+    const nextStep = slotState.find((s) => s.s !== StepState.VALID);
+
+    if (!nextStep) {
+        postBack(doneAction);
+        return Router.END;
+    }
+    const stepConfig = steps.find((s) => s.entity === nextStep.e);
+    res.setState({ _slotStep: stepConfig });
+    postBack(stepConfig.askAction);
+    return Router.END;
+}
+
+module.exports = {
+    getNextStep,
+    StepState,
+    StepType
+};

package/src/utils/stateVariables.js

@@ -26,15 +26,19 @@ const vars = {
      *
      * @param {string} key
      * @param {*} value
+     * @param {string} [path]
      * @returns {object}
      * @example
      * const { vars } = require('wingbot');
      * res.setState(vars.dialogContext('myKey', 'foovalue'))
      */
-    dialogContext (key, value) {
+    dialogContext (key, value, path = null) {
         return {
             [key]: value,
-            [`_~${key}`]: { t: DIALOG_CONTEXT }
+            [`_~${key}`]: {
+                t: DIALOG_CONTEXT,
+                ...(path && { p: path })
+            }
         };
     },
 
@@ -166,6 +170,17 @@ function mergeState (previousState, req, res, senderStateUpdate, firstInTurnover
             case DIALOG_CONTEXT: {
                 // compare state
 
+                if (!lastInTurnover || previousState._lastVisitedPath === undefined) {
+                    break;
+                }
+
+                if (value.p === true) {
+                    state[key].p = res.newState._lastVisitedPath;
+                } else if (value.p !== res.newState._lastVisitedPath) {
+                    delete state[key];
+                    delete state[referencedKey];
+                }
+
                 if (lastInTurnover
                     && previousState._lastVisitedPath !== undefined
                     && value.p !== res.newState._lastVisitedPath) {