wingbot 3.27.1 → 3.29.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.27.1",
+  "version": "3.29.0",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {
@@ -71,4 +71,4 @@
     "request": "^2.88.0",
     "request-promise-native": "^1.0.7"
   }
-}
+}

package/src/BotApp.js

@@ -262,7 +262,8 @@ class BotApp {
             pageId,
             appId,
             secret,
-            fetch: this._fetch
+            fetch: this._fetch,
+            tls: this._tls
         };
 
         const sender = new BotAppSender(options, senderId, message, this._senderLogger);

package/src/Request.js

@@ -1411,7 +1411,8 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
         data = {},
         refAction = null,
         refData = {},
-        timestamp = makeTimestamp()
+        timestamp = makeTimestamp(),
+        features = [FEATURE_TEXT]
     ) {
         const postback = {
             payload: {
@@ -1429,7 +1430,8 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
             sender: {
                 id: senderId
             },
-            postback
+            postback,
+            features
         };
     }
 
@@ -1725,4 +1727,24 @@ It looks like the bot isn't connected to class BotApp or the Processor is used w
 
 }
 
+/**
+ * @constant {string} FEATURE_VOICE channel supports voice messages
+ */
+Request.FEATURE_VOICE = FEATURE_VOICE;
+
+/**
+ * @constant {string} FEATURE_SSML channel supports SSML voice messages
+ */
+Request.FEATURE_SSML = FEATURE_SSML;
+
+/**
+ * @constant {string} FEATURE_PHRASES channel supports expected phrases messages
+ */
+Request.FEATURE_PHRASES = FEATURE_PHRASES;
+
+/**
+ * @constant {string} FEATURE_TEXT channel supports text communication
+ */
+Request.FEATURE_TEXT = FEATURE_TEXT;
+
 module.exports = Request;

package/src/Tester.js

@@ -14,6 +14,8 @@ const AnyResponseAssert = require('./testTools/AnyResponseAssert');
 const ResponseAssert = require('./testTools/ResponseAssert');
 
 const Router = require('./Router'); // eslint-disable-line no-unused-vars
+const ReducerWrapper = require('./ReducerWrapper'); // eslint-disable-line no-unused-vars
+const { FEATURE_TEXT } = require('./features');
 
 /**
  * Utility for testing requests
@@ -118,6 +120,11 @@ class Tester {
          * @prop {console} use own loggger
          */
         this.senderLogger = undefined;
+
+        /**
+         * @prop {string[]}
+         */
+        this.features = null;
     }
 
     dealloc () {
@@ -148,6 +155,15 @@ class Tester {
         this._responsesMock = [];
     }
 
+    /**
+     * Set features for all messages
+     *
+     * @param {string[]} [features]
+     */
+    setFeatures (features = [FEATURE_TEXT]) {
+        this.features = features;
+    }
+
     /**
      * Use tester as a connector :)
      *
@@ -164,6 +180,10 @@ class Tester {
             });
         }
 
+        if (this.features) {
+            Object.assign(message, { features: this.features });
+        }
+
         const messageSender = new ReturnSender({}, senderId, message, this.senderLogger);
         messageSender.simulatesOptIn = true;
 
@@ -259,7 +279,7 @@ class Tester {
     }
 
     /**
-     * Checks, that a plugin used a block as a responde
+     * Checks, that a plugin used a block as a response
      *
      * @param {string} blockName
      * @returns {this}
@@ -308,7 +328,6 @@ class Tester {
      *
      * @param {string} text
      * @returns {Promise}
-     *
      * @memberOf Tester
      */
     text (text) {
@@ -430,12 +449,11 @@ class Tester {
      * @param {string} [refAction=null] - referred action
      * @param {object} [refData={}] - referred action data
      * @returns {Promise}
-     *
      * @memberOf Tester
      */
     postBack (action, data = {}, refAction = null, refData = {}) {
         return this.processMessage(Request
-            .postBack(this.senderId, action, data, refAction, refData));
+            .postBack(this.senderId, action, data, refAction, refData, null));
     }
 
 }

package/src/resolvers/media.js

@@ -4,9 +4,12 @@
 'use strict';
 
 const Router = require('../Router');
+const getCondition = require('../utils/getCondition');
 const { stateData, cachedTranslatedCompilator } = require('./utils');
 
-function media (params, { isLastIndex }) {
+function media (params,
+    // @ts-ignore
+    { isLastIndex } = {}) {
     const { type, url } = params;
 
     const urlString = url || '';
@@ -19,7 +22,13 @@ function media (params, { isLastIndex }) {
         throw new Error(`Unsupported media type: ${type}`);
     }
 
+    const condition = getCondition(params, 'Media condition');
+
     return (req, res) => {
+        if (condition && !condition(req, res)) {
+            return ret;
+        }
+
         const data = stateData(req, res);
         const sendUrl = urlTemplate(data);
 

package/src/resolvers/message.js

@@ -2,10 +2,40 @@
  * @author David Menger
  */
 'use strict';
-
+// eslint-disable-next-line no-unused-vars
+const Responder = require('../Responder');
+// eslint-disable-next-line no-unused-vars
+const Request = require('../Request');
 const Router = require('../Router');
 const getCondition = require('../utils/getCondition');
-const { cachedTranslatedCompilator, stateData } = require('./utils');
+const {
+    stateData, getLanguageText, getLanguageTextObjects, randomizedCompiler
+} = require('./utils');
+const {
+    FEATURE_SSML, FEATURE_TEXT, FEATURE_VOICE
+} = require('../features');
+
+/**
+ * Returns voice control props from params
+ *
+ * @param {any} params
+ * @param {string} lang
+ * @returns {null | import('../Responder').VoiceControl}
+ */
+function getVoiceControl (params, lang = null) {
+    const voiceControl = {};
+
+    const voiceControlProps = ['speed', 'pitch', 'volume', 'voice', 'style', 'language'];
+
+    voiceControlProps.forEach((prop) => {
+        if (params[prop]) {
+            voiceControl[prop] = getLanguageText(params[prop], lang);
+        }
+    });
+
+    // if voiceControl is empty, return null
+    return Object.keys(voiceControl).length > 0 ? voiceControl : null;
+}
 
 function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
     return replies.map((reply) => {
@@ -45,7 +75,7 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
             action,
             condition,
             title: reply.title
-                ? cachedTranslatedCompilator(reply.title)
+                ? randomizedCompiler(reply.title)
                 : null,
             data: {}
         };
@@ -70,43 +100,108 @@ function parseReplies (replies, linksMap, allowForbiddenSnippetWords) {
     });
 }
 
+/**
+ * @param {import('./utils').Translations} text
+ * @param {string[]} features
+ * @param {string} lang
+ * @returns {{translations: import('./utils').TextObject[],ssmlAlternatives:string[] | null}}
+ */
+function findSupportedMessages (text, features, lang = null) {
+    let translations = getLanguageTextObjects(text, lang);
+
+    const useSSML = features.includes(FEATURE_SSML);
+    const useText = features.includes(FEATURE_TEXT);
+    const useVoice = features.includes(FEATURE_VOICE);
+
+    // filter out SSML alternatives - they will be used in voice control
+    let ssmlAlternatives = translations.filter((t) => t.p === 's').map((t) => t.t);
+    if (ssmlAlternatives.length === 0 || !useSSML) {
+        ssmlAlternatives = null;
+    }
+
+    translations = translations.filter((t) => t.p !== 's');
+
+    // find supported text alternatives
+    translations = translations.filter((translation) => {
+        // always use text+voice
+        if (!translation.p) {
+            return true;
+        }
+
+        // text only
+        if (useText && translation.p === 't') {
+            return true;
+        }
+
+        // voice (& SSML) only
+        if (useVoice && translation.p === 'v') {
+            return true;
+        }
+
+        return false;
+    });
+
+    return {
+        translations,
+        ssmlAlternatives
+    };
+}
+
 function message (params, {
+    // @ts-ignore
     isLastIndex, isLastMessage, linksMap, allowForbiddenSnippetWords
-}) {
+} = {}) {
+
     if (typeof params.text !== 'string' && !Array.isArray(params.text)) {
         throw new Error('Message should be a text!');
     }
 
-    const textTemplate = cachedTranslatedCompilator(params.text);
-
+    // parse quick replies
     let quickReplies = null;
-
     if (params.replies && !Array.isArray(params.replies)) {
         throw new Error('Replies should be an array');
     } else if (params.replies && params.replies.length > 0) {
         quickReplies = parseReplies(params.replies, linksMap, allowForbiddenSnippetWords);
     }
 
+    // compile condition
     const condition = getCondition(params, 'Message condition', allowForbiddenSnippetWords);
 
     const ret = isLastIndex ? Router.END : Router.CONTINUE;
 
+    /**
+     * @param {Request} req
+     * @param {Responder} res
+     */
     return (req, res) => {
-        if (condition !== null) {
-            if (!condition(req, res)) {
-                return ret;
-            }
+        if (condition && !condition(req, res)) {
+            return ret;
         }
-
         const data = stateData(req, res);
+
+        // filter supported messages
+        /** @type {{translations:import('./utils').TextObject[],ssmlAlternatives:string[]}} */
+        const supportedText = findSupportedMessages(
+            params.text,
+            req.features,
+            data.lang
+        );
+
+        // find random alternative
+        const textTemplate = randomizedCompiler([{
+            l: data.lang,
+            t: supportedText.translations.map((x) => x.t)
+        }]);
+
         const text = textTemplate(data)
             .trim();
 
+        let sendReplies;
         if (quickReplies) {
             const okQuickReplies = quickReplies
                 .filter((reply) => reply.condition(req, res));
 
-            const sendReplies = okQuickReplies
+            sendReplies = okQuickReplies
                 .filter((reply) => reply.title
                     || reply.isLocation
                     || reply.isEmail
@@ -123,8 +218,6 @@ function message (params, {
                     return rep;
                 });
 
-            res.text(text, sendReplies);
-
             okQuickReplies
                 .filter((reply) => !reply.title && reply.match)
                 .forEach(({
@@ -134,10 +227,27 @@ function message (params, {
                 });
         } else {
             // replies on last index will be present, so the addQuickReply will be working
-            const sendReplies = isLastMessage ? [] : undefined;
-            res.text(text, sendReplies);
+            sendReplies = isLastMessage ? [] : undefined;
         }
 
+        // generate voice control
+        let voiceControl = getVoiceControl(params, data.lang);
+        if (supportedText.ssmlAlternatives) {
+            // find SSML alternative
+            const ssmlAlternativeTemplate = randomizedCompiler([{
+                l: data.lang,
+                t: supportedText.ssmlAlternatives
+            }]);
+
+            voiceControl = {
+                ...voiceControl,
+                ssml: ssmlAlternativeTemplate(data)
+                    .trim()
+            };
+        }
+
+        res.text(text, sendReplies, voiceControl);
+
         return ret;
     };
 }

package/src/resolvers/utils.js

@@ -19,6 +19,28 @@ const WEBVIEW_FULL = 'full';
 const WEBVIEW_TALL = 'tall';
 const WEBVIEW_COMPACT = 'compact';
 
+/**
+ * @typedef {Translation[] | Translation | string[] | string} Translations
+ */
+
+/**
+ * @typedef {object} TextObject
+ * @prop {string} t - text
+ * @prop {string} l - lang
+ * @prop {string|null} p - purpose
+ */
+
+/**
+ * @typedef Translation
+ * @property {string|string[]} t - text alternatives
+ * @property {string | null} l - language
+ * @property {string|string[]} [p] - purposes
+ * null = default + voice
+ * t = text
+ * v = voice
+ * s = ssml
+ */
+
 function isArrayOfObjects (translations) {
     return Array.isArray(translations)
         && typeof translations[0] === 'object'
@@ -36,18 +58,20 @@ function isTextObjectEmpty (text) {
 }
 
 /**
- *
- * @param {{t:string,l:string}[]|string} translations
+ * @param {Translations} translations
  * @param {string} [lang]
  * @returns {null|string}
  */
 function getLanguageText (translations, lang = null) {
     let foundText;
+
     if (isArrayOfObjects(translations)) {
         if (lang) {
+            // @ts-ignore
             foundText = translations.find((t) => t.l === lang);
         }
         if (isTextObjectEmpty(foundText)) {
+            // @ts-ignore
             foundText = translations.find((t) => !isTextObjectEmpty(t));
         }
         foundText = foundText ? foundText.t : null;
@@ -63,6 +87,58 @@ function getLanguageText (translations, lang = null) {
     }
     return foundText || '';
 }
+/**
+ *
+ * @param {Translations} translations
+ * @param {string} [lang]
+ * @returns {TextObject[]}
+ */
+function getLanguageTextObjects (translations, lang = null) {
+    /** @type {{t:string|string[],l?:string,p?:string|string[]}[]} */
+    let foundTexts;
+
+    if (!Array.isArray(translations) || typeof translations[0] === 'string') {
+        // @ts-ignore
+        foundTexts = [{ t: translations, l: lang }];
+    } else { // is array of objects
+        foundTexts = translations
+            // @ts-ignore
+            .filter(({ l = null, ...to }) => l === lang && !isTextObjectEmpty(to));
+
+        if (foundTexts.length === 0) {
+            const { l: firstNonEmptyLang = null } = translations
+                // @ts-ignore
+                .find((to) => !isTextObjectEmpty(to)) || {};
+
+            foundTexts = translations
+                // @ts-ignore
+                .filter(({ l = null, ...to }) => l === firstNonEmptyLang && !isTextObjectEmpty(to));
+        }
+    }
+
+    return foundTexts
+        .reduce((a, to) => {
+            if (Array.isArray(to.t)) {
+                const purposes = Array.isArray(to.p)
+                    ? to.p
+                    : [to.p];
+                a.push(
+                    ...to.t.map((t, i) => ({
+                        ...to, t, p: purposes[i] || null
+                    }))
+                );
+            } else {
+                a.push(to);
+            }
+            return a;
+        }, [])
+        .filter((to) => !!to.t)
+        .map(({
+            t, l = null, p = null, ...rest
+        }) => ({
+            t, l, p, ...rest
+        }));
+}
 
 function randomizedCompiler (text, lang) {
     const texts = getLanguageText(text, lang);
@@ -100,6 +176,13 @@ function randomizedCompiler (text, lang) {
     };
 }
 
+/**
+ * l - language
+ * t - alternatives
+ *
+ * @param {{l:string,t:string[]}[] | string} text
+ * @returns {(state:any)=>string}
+ */
 function cachedTranslatedCompilator (text) {
     const cache = new Map();
 
@@ -194,7 +277,9 @@ function processButtons (
 
 module.exports = {
     getLanguageText,
+    getLanguageTextObjects,
     cachedTranslatedCompilator,
+    randomizedCompiler,
     getText,
     stateData,