wingbot 3.34.0 → 3.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wingbot",
-  "version": "3.34.0",
+  "version": "3.36.0",
   "description": "Enterprise Messaging Bot Conversation Engine",
   "main": "index.js",
   "scripts": {
@@ -46,7 +46,7 @@
     "eslint-plugin-react": "^7.29.4",
     "graphql-markdown": "^6.0.0",
     "jsdoc-to-markdown": "^7.1.1",
-    "mocha": "^9.2.2",
+    "mocha": "^10.0.0",
     "nyc": "^15.1.0",
     "rimraf": "^3.0.2",
     "sinon": "^13.0.1",

package/src/Ai.js

@@ -40,6 +40,8 @@ let uq = 1;
 
 /** @typedef {import('./Request').IntentAction} IntentAction */
 /** @typedef {import('./Request')} Request */
+/** @typedef {import('./Responder')} Responder */
+/** @typedef {import('./wingbot/CachedModel').Result} Result */
 /** @typedef {import('./wingbot/CustomEntityDetectionModel').Phrases} Phrases */
 
 /**
@@ -348,13 +350,13 @@ class Ai {
         const rules = this.matcher.preprocessRule(intent);
         const matcher = this._createIntentMatcher(rules, usedEntities);
 
-        return async (req) => {
+        return async (req, res) => {
             if (!req.isTextOrIntent()) {
                 return false;
             }
 
             if (!req.intents) {
-                await this._loadIntents(req);
+                await this._loadIntents(req, res);
             }
 
             const winningIntent = matcher(req);
@@ -523,9 +525,10 @@ class Ai {
     /**
      *
      * @param {Request} req
+     * @param {Responder} [res]
      * @returns {Promise}
      */
-    async preloadAi (req) {
+    async preloadAi (req, res = null) {
         if (req.supportsFeature(req.FEATURE_PHRASES)) {
             const model = this._getModelForRequest(req, false);
 
@@ -534,7 +537,7 @@ class Ai {
                     .catch(() => {});
             }
         }
-        return this._preloadIntent(req);
+        return this._preloadIntent(req, res);
     }
 
     /**
@@ -552,12 +555,43 @@ class Ai {
         return CustomEntityDetectionModel.getEmptyPhrasesObject();
     }
 
-    async _preloadIntent (req) {
+    /**
+     *
+     * @param {Request} req
+     * @param {Responder} res
+     * @param {Result} result
+     * @returns {void}
+     */
+    _setResultToReqRes (req, res, result) {
+        const { text = null, intents, entities = [] } = result;
+        Object.assign(req, { intents, entities, _anonymizedText: text });
+
+        if (!res) {
+            return;
+        }
+
+        const entitiesObj = (entities || []).reduce((o, { entity, value }) => {
+            const list = o[entity] || [];
+            list.push(value);
+            return Object.assign(o, { [entity]: list });
+        }, {});
+
+        res.setData({
+            '@': entitiesObj
+        });
+    }
+
+    /**
+     *
+     * @param {Request} req
+     * @param {Responder} [res]
+     * @returns {Promise}
+     */
+    async _preloadIntent (req, res = null) {
         const mockIntent = this._getMockIntent(req);
 
         if (mockIntent) {
-            req.intents = mockIntent.intents;
-            req.entities = mockIntent.entities;
+            this._setResultToReqRes(req, res, mockIntent);
             return;
         }
 
@@ -571,15 +605,15 @@ class Ai {
                 req.intents = [];
                 return;
             }
-            await this._loadIntents(req, model);
+            await this._loadIntents(req, res, model);
         } else {
             req.intents = [];
         }
     }
 
-    async _loadIntents (req, model = null) {
-        const { text = null, intents, entities = [] } = await this._queryModel(req, model);
-        Object.assign(req, { intents, entities, _anonymizedText: text });
+    async _loadIntents (req, res = null, model = null) {
+        const result = await this._queryModel(req, model);
+        this._setResultToReqRes(req, res, result);
     }
 
     async _queryModel (req, useModel = null) {

package/src/BotApp.js

@@ -46,6 +46,15 @@ const DEFAULT_API_URL = 'https://orchestrator-api.wingbot.ai';
  * @prop {object} headers
  */
 
+function defaultMsg (senderId, pageId) {
+    return {
+        sender: { id: senderId },
+        recipient: { id: pageId },
+        mid: null,
+        timestamp: Date.now()
+    };
+}
+
 /**
  * Adapter for Wingbot flight director
  *
@@ -239,32 +248,55 @@ class BotApp {
             };
         }
 
+        const sender = await this.createSender(senderId, pageId, message, secret, appId);
+        const res = await this._processor.processMessage(message, pageId, sender, { appId });
+        await this._processSenderResponses(sender, senderId, pageId, headers);
+
+        return {
+            status: res.status,
+            response_to_mid: message.mid,
+            messaging: []
+        };
+    }
+
+    /**
+     * Creates a Sender to be able, for example, to upload files
+     *
+     * @param {string} senderId
+     * @param {string} pageId
+     * @param {object} [message]
+     * @param {string|Promise<string>} [secret]
+     * @param {string} appId
+     * @returns {Promise<BotAppSender>}
+     */
+    async createSender (
+        senderId,
+        pageId,
+        message = defaultMsg(senderId, pageId),
+        secret = this._secret,
+        appId = this._appId
+    ) {
+        const useSecret = await Promise.resolve(secret);
+
+        const setResponseToMid = message.response_to_mid || message.mid;
+
         const options = {
             ...this._returnSenderOptions,
             apiUrl: this._apiUrl,
             pageId,
             appId,
-            secret,
+            secret: useSecret,
             mid: setResponseToMid,
             fetch: this._fetch,
             tls: this._tls
         };
 
-        const sender = new BotAppSender(options, senderId, message, this._senderLogger);
-        const res = await this._processor.processMessage(message, pageId, sender, { appId });
-        await this._processSenderResponses(sender, senderId, pageId, headers);
-
-        return {
-            status: res.status,
-            response_to_mid: message.mid,
-            messaging: []
-        };
+        return new BotAppSender(options, senderId, message, this._senderLogger);
     }
 
     /**
      * Compatibility method for Notification engine
      *
-     * @deprecated
      * @param {object} message - wingbot chat event
      * @param {string} senderId - chat event sender identifier
      * @param {string} pageId - channel/page identifier

package/src/Processor.js

@@ -541,7 +541,7 @@ class Processor extends EventEmitter {
                 }
             }
 
-            await Ai.ai.preloadAi(req);
+            await Ai.ai.preloadAi(req, res);
 
             // @deprecated backward compatibility
             const aByAi = req.actionByAi();

package/src/resolvers/utils.js

@@ -14,6 +14,7 @@ const TYPE_SHARE = 'element_share';
 const TYPE_URL = 'web_url';
 const TYPE_URL_WITH_EXT = 'web_url_extension';
 const TYPE_POSTBACK = 'postback';
+const TYPE_ATTACHMENT = 'attachment';
 
 const WEBVIEW_FULL = 'full';
 const WEBVIEW_TALL = 'tall';
@@ -227,10 +228,11 @@ function processButtons (
         editableCondition,
         setState
     }) => {
+
         if (hasCondition) {
             const condition = getCondition({
                 hasCondition, conditionFn, hasEditableCondition, editableCondition
-            }, context, 'Quick reply condition');
+            }, context, 'Button condition');
 
             if (!condition(req, res)) {
                 return;
@@ -244,7 +246,8 @@ function processButtons (
             url,
             webviewHeight = WEBVIEW_TALL,
             targetRouteId,
-            action
+            action,
+            payload
         } = btnAction;
 
         const isExtUrl = type === TYPE_URL_WITH_EXT;
@@ -273,6 +276,9 @@ function processButtons (
             case TYPE_SHARE:
                 elem.shareButton(btnTitleText);
                 break;
+            case TYPE_ATTACHMENT:
+                elem.attachmentButton(btnTitleText, payload);
+                break;
             default:
         }
     });

package/src/templates/ButtonTemplate.js

@@ -6,6 +6,38 @@
 const BaseTemplate = require('./BaseTemplate');
 const { makeAbsolute } = require('../utils');
 
+/**
+ * @typedef MarkdownPayload
+ * @prop {"text/markdown"} contentType
+ * @prop {string} content
+ */
+
+/**
+ * Designer payload type
+ *
+ * @typedef {MarkdownPayload} Payload
+ */
+
+/**
+ * @typedef EncodedPayload
+ * @prop {string} content
+ * @prop {"text/markdown"} content_type
+ */
+
+/**
+ * Encodes different types of payloads from designer snapshot to payload for chat
+ * Content is Base64 encoded.
+ *
+ * @param {Payload} payload
+ * @returns {EncodedPayload}
+ */
+function encodePayload ({ content, contentType }) {
+    return {
+        content: Buffer.from(content).toString('base64'),
+        content_type: contentType
+    };
+}
+
 /**
  * Helps with creating of button template
  * Instance of button template is returned by {Responder}
@@ -92,6 +124,31 @@ class ButtonTemplate extends BaseTemplate {
         return this;
     }
 
+    /**
+     * Adds button, which opens a popup with content on click.
+     *
+     * @param {string} title
+     * @param {Payload} payload
+     * @returns {this}
+     *
+     * @example
+     * res.button('text')
+     *  .attachmentButton('button title', {
+     *      content: '# Heading 1',
+     *      contentType: 'text/markdown'
+     *   })
+     *  .send();
+     *
+     */
+    attachmentButton (title, payload) {
+        this.buttons.push({
+            type: 'attachment',
+            title: this._t(title),
+            payload: encodePayload(payload)
+        });
+        return this;
+    }
+
     /**
      *
      * @returns {this}

package/src/utils/stateData.js

@@ -3,8 +3,19 @@
  */
 'use strict';
 
+/** @typedef {import('../Request')} Request */
+/** @typedef {import('../Responder')} Responder */
+
+/**
+ *
+ * @param {Request} req
+ * @param {Responder} res
+ * @param {object} configuration
+ * @returns {object}
+ */
 module.exports = function stateData (req, res = null, configuration = null) {
     const c = configuration || req.configuration;
+
     return {
         ...req.state,
         ...(res ? res.newState : {}),