wingbot 3.37.2 → 3.38.0-alpha.1

package/package.json

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

package/src/Ai.js

@@ -49,7 +49,7 @@ let uq = 1;
  */
 class Ai {
 
-    constructor (matcher = new AiMatching()) {
+    constructor () {
         this._keyworders = new Map();
 
         /**
@@ -111,7 +111,7 @@ class Ai {
          *
          * @type {AiMatching}
          */
-        this.matcher = matcher;
+        this.matcher = new AiMatching(this);
     }
 
     /**

package/src/AiMatching.js

@@ -91,6 +91,11 @@ const COMPARE = {
  * @prop {object} [state]
  */
 
+/**
+ * @typedef {object} ConfidenceProvider
+ * @prop {number} confidence
+ */
+
 /**
  * @class {AiMatching}
  *
@@ -98,7 +103,11 @@ const COMPARE = {
  */
 class AiMatching {
 
-    constructor () {
+    /**
+     *
+     * @param {ConfidenceProvider} ai
+     */
+    constructor (ai = { confidence: 0.8 }) {
         /**
          * When the entity is optional, the final score should be little bit lower
          * (0.001 by default)
@@ -138,6 +147,8 @@ class AiMatching {
          * (1 by default)
          */
         this.stateEntityScore = 1;
+
+        this._ai = ai;
     }
 
     get redundantHandicap () {
@@ -447,11 +458,29 @@ class AiMatching {
                 ? score - noIntentHandicap
                 : (regexpScore + score) / 2;
 
+            const matchedEntitiesTextLength = matched.reduce((tot, entity) => (
+                typeof entity.end === 'number' && typeof entity.start === 'number' && tot !== null
+                    ? (tot + (entity.end - entity.start))
+                    : null
+            ), 0);
+
+            let finalScore = (baseScore - handicap)
+                * (this.multiMatchGain ** countOfAdditionalItems);
+
+            const textLength = req.text().length;
+
+            if (matchedEntitiesTextLength && textLength) {
+                const remainingScore = Math.max(0, Math.min(1, finalScore) - (
+                    this._ai.confidence + this.redundantEntityHandicap
+                ));
+
+                finalScore -= (matchedEntitiesTextLength / textLength) * remainingScore;
+            }
+
             return {
                 intent: null,
                 entities: matched,
-                score: (baseScore - handicap)
-                    * (this.multiMatchGain ** countOfAdditionalItems)
+                score: finalScore
             };
         }
 

package/src/resolvers/hbs.js

@@ -5,7 +5,31 @@
 
 let handlebars;
 try {
+    // @ts-ignore
     handlebars = module.require('handlebars');
+
+    handlebars.registerHelper('lang', function langHelper (content) {
+        if (typeof content !== 'object' || !content) {
+            return content;
+        }
+
+        const { lang } = this;
+
+        if (content[lang]) {
+            return content[lang];
+        }
+
+        if (Array.isArray(content)) {
+            const entry = content.find((c) => c
+                && (!lang || c.l === lang || c.lang === lang) && (c.t || c.text));
+
+            if (entry) {
+                return entry.text || entry.t;
+            }
+        }
+
+        return content[Object.keys(content)[0]];
+    });
 } catch (er) {
     handlebars = { compile: (text) => () => text };
 }

package/src/resolvers/index.js

@@ -16,6 +16,7 @@ const button = require('./button');
 const subscribtions = require('./subscribtions');
 const setState = require('./setState');
 const expectedInput = require('./expectedInput');
+const skip = require('./skip');
 
 module.exports = {
     path,
@@ -30,5 +31,6 @@ module.exports = {
     button,
     subscribtions,
     setState,
-    expectedInput
+    expectedInput,
+    skip
 };

package/src/resolvers/message.js

@@ -195,9 +195,6 @@ function message (params, context = {}) {
      * @param {Responder} res
      */
     return (req, res) => {
-        if (condition && !condition(req, res)) {
-            return ret;
-        }
         const data = stateData(req, res, configuration);
 
         // filter supported messages
@@ -216,30 +213,51 @@ function message (params, context = {}) {
         const text = textTemplate(data)
             .trim();
 
+        res.setData({ $this: text });
+        if (condition && !condition(req, res)) {
+            res.setData({ $this: null });
+            return ret;
+        }
+        res.setData({ $this: null });
+
         let sendReplies;
         if (quickReplies) {
-            const okQuickReplies = quickReplies
-                .filter((reply) => reply.condition(req, res));
-
-            sendReplies = okQuickReplies
+            sendReplies = quickReplies
                 .filter((reply) => reply.title
                     || reply.isLocation
                     || reply.isEmail
                     || reply.isPhone)
                 .map((reply) => {
-                    const rep = (reply.isLocation || reply.isEmail || reply.isPhone)
-                        ? ({ ...reply })
-                        : ({ ...reply, title: reply.title(data) });
+                    let $this = null;
+                    let rep;
+
+                    if (reply.isLocation || reply.isEmail || reply.isPhone) {
+                        rep = { ...reply };
+                    } else {
+                        const title = reply.title(data);
+                        $this = title;
+                        rep = { ...reply, title };
+                    }
+
+                    if (typeof rep.condition !== 'function') {
+                        return rep;
+                    }
 
-                    if (typeof rep.condition === 'function') {
-                        delete rep.condition;
+                    res.setData({ $this });
+                    if (!rep.condition(req, res)) {
+                        res.setData({ $this: null });
+                        return null;
                     }
+                    res.setData({ $this: null });
+
+                    delete rep.condition;
 
                     return rep;
-                });
+                })
+                .filter((rep) => rep !== null);
 
-            okQuickReplies
-                .filter((reply) => !reply.title && reply.match)
+            quickReplies
+                .filter((reply) => !reply.title && reply.match && reply.condition(req, res))
                 .forEach(({
                     match, action, data: replyData, setState, aiTitle
                 }) => {

package/src/resolvers/skip.js

@@ -0,0 +1,57 @@
+/*
+ * @author David Menger
+ */
+'use strict';
+
+const Router = require('../Router');
+const getCondition = require('../utils/getCondition');
+
+/** @typedef {import('../BuildRouter').BotContext} BotContext */
+/** @typedef {import('../Router').Resolver} Resolver */
+
+/**
+ *
+ * @param {object} params
+ * @param {BotContext} context
+ * @returns {Resolver}
+ */
+function skip (params, context = {}) {
+    const { isLastIndex } = context;
+    const { type } = params;
+
+    const ret = isLastIndex ? Router.END : Router.CONTINUE;
+
+    if (['skip', 'end', 'intent'].indexOf(type) === -1) {
+        throw new Error(`Unsupported skip type: ${type}`);
+    }
+
+    const condition = getCondition(params, context, 'Skip condition');
+
+    return (req, res, postBack) => {
+        if (condition && !condition(req, res)) {
+            return ret;
+        }
+
+        switch (type) {
+            case 'end':
+                return Router.END;
+            case 'skip':
+                return Router.BREAK;
+            case 'intent': {
+                let { lastAiActionsIndex = 0 } = req.actionData();
+                const actions = req.aiActions();
+                lastAiActionsIndex++;
+                if (!actions[lastAiActionsIndex] || !actions[lastAiActionsIndex].aboveConfidence) {
+                    return Router.BREAK;
+                }
+                postBack(actions[lastAiActionsIndex].action, { lastAiActionsIndex });
+                return Router.END;
+            }
+
+            default:
+                return ret;
+        }
+    };
+}
+
+module.exports = skip;

package/src/utils/customCondition.js

@@ -88,8 +88,23 @@ const ARRAY_LENGTH_OPERATORS = [
 const compare = (variable, operator, value = undefined) => {
     const isArrayLengthCompare = ARRAY_LENGTH_OPERATORS.includes(operator);
     if (Array.isArray(variable) && !isArrayLengthCompare) {
-        // @todo if value === number && operator === '=='
-        return variable.some((variableElement) => compare(variableElement, operator, value));
+        if (operator === ConditionOperators['==']
+            && (typeof value === 'number' || isStringNumber(value))) {
+
+            const numeric = toNumber(value);
+            return numeric === variable.length;
+        }
+
+        if (operator === ConditionOperators['not contains']) {
+            return variable
+                .every((variableElement) => !compare(variableElement, ConditionOperators['=='], value));
+        }
+
+        const useOperator = operator === ConditionOperators.contains
+            ? ConditionOperators['==']
+            : operator;
+
+        return variable.some((variableElement) => compare(variableElement, useOperator, value));
     }
 
     if (variable && typeof variable === 'object' && !isArrayLengthCompare) {

package/src/utils/getUpdate.js

@@ -161,6 +161,8 @@ function getSetState (setState, req, res = null, useState = null, configuration
                     valAsArray.shift();
                 } else if (val._$pop) {
                     valAsArray.pop();
+                } else if (val._$pushT) {
+                    valAsArray.push(req.text());
                 } else {
                     const value = val._$add || val._$rem || val._$push || val._$set;
                     const [, entity, rear] = `${value}`.match(ENTITY_HBS_REGEXP) || [];

package/src/utils/stateData.js

@@ -17,11 +17,12 @@ module.exports = function stateData (req, res = null, configuration = null) {
     const c = configuration || req.configuration;
 
     return {
+        c,
+        configuration: c,
         ...req.state,
         ...(res ? res.newState : {}),
         ...req.actionData(),
         ...(res ? res.data : {}),
-        c,
-        configuration: c
+        $input: req.text()
     };
 };