@tiledesk/tiledesk-tybot-connector 0.2.26 → 0.2.28

package/CHANGELOG.md

@@ -5,6 +5,15 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+### v0.2.28
+- DirSetAttribute, added support for attribute-filling in constants
+- DirSetAttribute, added function JSONparse
+- Added support for Globals (aka Secrets)
+
+### v0.2.27
+- Added support for removing empty text from replies: TiledeskChatbotUtil.removeEmptyReplyCommands()
+- Removed non-user-defined attributes from /ext/parameters method
+
 ### v0.2.26
 - Updated Qapla Action (tracking number from filler)
 

package/TiledeskExpression.js

@@ -209,6 +209,10 @@ class TiledeskExpression {
         "roundAsNumber": {
             name: "roundAsNumber",
             applyPattern: "TiledeskMath.round(Number(#1))"
+        },
+        "JSONparse": {
+            name: "JSONparse",
+            applyPattern: "JSON.parse(String(#1))"
         }
     }
 
@@ -230,8 +234,8 @@ class TiledeskExpression {
     }
 
     evaluateJavascriptExpression(expression, context) {
-        // console.log("(evaluateJavascriptExpression) evaluating:", expression)
-        // console.log("context:", context)
+        console.log("(evaluateJavascriptExpression) evaluating:", expression)
+        console.log("context:", context)
         let res = null;
         try {
             const vm = new VM({

package/index.js

@@ -221,6 +221,11 @@ router.post('/ext/:botid', async (req, res) => {
   
 });
 
+router.post('/hooks/:hookid', async (req, res) => {
+  // chatbot_id + intend_id
+
+});
+
 router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) => {
   res.json({success:true});
   const projectId = req.params.projectId;
@@ -359,7 +364,18 @@ router.get('/ext/parameters/requests/:requestid', async (req, res) => {
       TiledeskChatbotConst.REQ_REQUEST_ID_KEY,
       TiledeskChatbotConst.REQ_USER_AGENT_KEY,
       TiledeskChatbotConst.REQ_USER_LANGUAGE_KEY,
-      TiledeskChatbotConst.REQ_USER_SOURCE_PAGE_KEY
+      TiledeskChatbotConst.REQ_USER_SOURCE_PAGE_KEY,
+      TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_TYPE_KEY,
+      TiledeskChatbotConst.REQ_TRANSCRIPT_KEY,
+      TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_KEY,
+      "lastUserImageURL", // image
+      "lastUserImageName", // image
+      "lastUserImageWidth", // image
+      "lastUserImageHeight", // image
+      "lastUserImageType", // image
+      "lastUserDocumentURL", // file
+      "lastUserDocumentName", // file
+      "lastUserDocumentType" // file
     ]
     let userParams = {};
     if (parameters) {

package/models/TiledeskChatbot.js

@@ -626,9 +626,9 @@ class TiledeskChatbot {
         attributes_native_values[key] = JSON.parse(value);
       }
     }
-    else {
-      console.error("An error occurred. 'attributes__as_string_map' is null!");
-    }
+    // else {
+    //   console.error("Warning: 'attributes__as_string_map' is null!");
+    // }
     return attributes_native_values;
   }
 

package/models/TiledeskChatbotConst.js

@@ -5,6 +5,7 @@ class TiledeskChatbotConst {
     static REQ_REQUEST_ID_KEY = "conversation_id";
     static REQ_CHATBOT_NAME_KEY = "chatbot_name";
     static REQ_LAST_USER_TEXT_KEY = "last_user_text";
+    static REQ_LAST_USER_TEXT_v2_KEY = "lastUserText";
     static REQ_LAST_MESSAGE_ID_KEY = "last_message_id";
     static REQ_COUNTRY_KEY = "user_country";
     static REQ_CITY_KEY = "user_city";
@@ -15,6 +16,10 @@ class TiledeskChatbotConst {
     static REQ_END_USER_ID_KEY = "user_id";
     static REQ_END_USER_IP_ADDRESS_KEY = "user_ip_address";
     static REQ_CHAT_URL = "chat_url";
+    static REQ_LAST_USER_MESSAGE_TYPE_KEY = "lastUserMessageType";
+    static REQ_TRANSCRIPT_KEY = "transcript";
+    static REQ_LAST_USER_MESSAGE_KEY = "lastUserMessage";
+    static REQ_CHAT_CHANNEL = "chatChannel";
 
     // static REQ_DEPARTMENT_ID_KEY = "tdDepartmentId";
     // static REQ_PROJECT_ID_KEY = "projectId";

package/models/TiledeskChatbotUtil.js

@@ -237,6 +237,57 @@ class TiledeskChatbotUtil {
         }
     }
 
+    static removeEmptyReplyCommands(message) {
+        try {
+            if (message && message.attributes && message.attributes.commands && message.attributes.commands.length > 0) {
+                let commands = message.attributes.commands;
+                
+                for (let i = commands.length - 1; i >= 0; i--) {
+                    // console.log("...commands[" + i + "]");
+                    if (commands[i].type === "message") { // is a message, not a "wait"
+                        // console.log("commands[i]:", commands[i].message.text);
+                        // let textEmpty = false;
+                        if (commands[i].message) {
+                            if (commands[i].message.type === "text") { // check text commands
+                                if (( commands[i].message.text && commands[i].message.text.trim() === "") || !commands[i].message.text) {
+                                    console.log("deleting command:", commands[i]);
+                                    commands.splice(i, 1);
+                                    if (commands[i-1]) {
+                                        if (commands[i-1].type === "wait") {
+                                            commands.splice(i-1, 1);
+                                            i--;
+                                            console.log("deleted wait");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            // for (let i = 0; i < commands.length; i++) {
+            //   if (commands[i].type === 'message' && commands[i].message && commands[i].message.text) {
+            //     if (this.log) {console.log("[" + commands[i].message.lang + "]commands[i].message.text:", commands[i].message.text);}
+            //   }
+            // }
+            }
+        }
+        catch(error) {
+            log.error("error while checking", error)
+        }
+        return message;
+    }
+
+    /*
+    returns true if a valid message for a reply (i.e. at least one valid - non empty - message command)
+    */
+    static isValidReply(message) {
+        if (message && message.attributes && message.attributes.commands && message.attributes.commands.length > 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
     static totalMessageWait(message) {
         if (!message) {
           return;
@@ -337,17 +388,17 @@ class TiledeskChatbotUtil {
         
         if (message.text && message.sender !== "_tdinternal") {
             await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_TEXT_KEY, message.text); // DEPRECATED
-            await chatbot.addParameter("lastUserText", message.text);
+            await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_TEXT_v2_KEY, message.text);
             if (message.channel) {
                 if (message.channel.name === "chat21") {
-                    await chatbot.addParameter("chatChannel", "web"); // renames the channel in chat21
+                    await chatbot.addParameter(TiledeskChatbotConst.REQ_CHAT_CHANNEL, "web"); // renames the channel in chat21
                 }
                 else {
-                    await chatbot.addParameter("chatChannel", message.channel.name);
+                    await chatbot.addParameter(TiledeskChatbotConst.REQ_CHAT_CHANNEL, message.channel.name);
                 }
             }
-            await chatbot.addParameter("lastUserMessageType", message.type);
-            await chatbot.addParameter("lastUserMessage", TiledeskChatbotUtil.lastUserMessageFrom(message)); // JSON TYPE *NEW
+            await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_TYPE_KEY, message.type);
+            await chatbot.addParameter(TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_KEY, TiledeskChatbotUtil.lastUserMessageFrom(message)); // JSON TYPE *NEW
             // get image
             if (message.type && message.type === "image" && message.metadata) {
                 // "text": "\nimage text",
@@ -467,20 +518,39 @@ class TiledeskChatbotUtil {
           }
         }
         
-
+        const _bot = chatbot.bot; // aka FaqKB
+        if (chatbot.log) {
+            console.log("Adding Globals to context..., chatbot.attributes?", JSON.stringify(_bot));
+        }
+        
+        if (_bot.attributes && _bot.attributes.globals) {
+            if (chatbot.log) {console.log("Got Globals:", JSON.stringify(_bot.attributes.globals));}
+            _bot.attributes.globals.forEach(async (global_var) => {
+                if (chatbot.log) {console.log("Adding global:", global_var.key, "value:", global_var.value);}
+                await chatbot.addParameter(global_var.key, global_var.value);
+            });
+        }
+        // await chatbot.addParameter("testVar",
+        //     {
+        //         name: "Andrea",
+        //         coords: {
+        //             x: 2, y: 1
+        //         }
+        //     }
+        // );
         
         if (chatbot.log) {
           // console.log("tdcache:", chatbot.tdcache);
           console.log("requestId:", requestId);
           console.log("KEY:", TiledeskChatbotConst.REQ_PROJECT_ID_KEY);
-          console.log("TiledeskChatbot:", TiledeskChatbot);
+        //   console.log("TiledeskChatbot:", TiledeskChatbot);
           let proj_ = await chatbot.getParameter(TiledeskChatbotConst.REQ_PROJECT_ID_KEY);
           console.log("request parameter proj_:", proj_);
           const all_parameters = await chatbot.allParameters();
           for (const [key, value] of Object.entries(all_parameters)) {
             // const value = all_parameters[key];
             const value_type = typeof value;
-            if (chatbot.log) {console.log("request parameter:", key, "value:", value, "type:", value_type)}
+            if (chatbot.log) {console.log("REQUEST ATTRIBUTE:", key, "VALUE:", value, "TYPE:", value_type)}
           }
         }
     } catch(error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -25,6 +25,7 @@ const { DirCondition } = require('./directives/DirCondition');
 const { DirJSONCondition } = require('./directives/DirJSONCondition');
 const { DirAssign } = require('./directives/DirAssign');
 const { DirSetAttribute } = require('./directives/DirSetAttribute');
+const { DirSetAttributeV2 } = require('./directives/DirSetAttributeV2');
 const { DirWebRequest } = require('./directives/DirWebRequest');
 const { DirWebRequestV2 } = require('./directives/DirWebRequestV2');
 const { DirCode } = require('./directives/DirCode');
@@ -370,6 +371,13 @@ class DirectivesChatbotPlug {
         this.process(next_dir);
       });
     }
+    else if (directive_name === Directives.SET_ATTRIBUTE_V2) {
+      // console.log("...DirSetAttribute");
+      new DirSetAttributeV2(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      });
+    }
     // else if (directive_name === Directives.WHEN_OPEN) {
     //   // DEPRECATED
     //   const whenOpenDir = new DirWhenOpen(

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -97,18 +97,24 @@ class DirReply {
       }
     }
     // send!
-    message.senderFullname = this.context.chatbot.bot.name;
-    if (this.log) {console.log("Reply:", JSON.stringify(message))};
-    await TiledeskChatbotUtil.updateConversationTranscript(this.context.chatbot, message);
+    const cleanMessage = TiledeskChatbotUtil.removeEmptyReplyCommands(message);
+    if (!TiledeskChatbotUtil.isValidReply(cleanMessage)) {
+      console.log("invalid message", cleanMessage);
+      callback(); // cancel reply operation
+    }
+    // console.log("valid message!", cleanMessage);
+    cleanMessage.senderFullname = this.context.chatbot.bot.name;
+    if (this.log) {console.log("Reply:", JSON.stringify(cleanMessage))};
+    await TiledeskChatbotUtil.updateConversationTranscript(this.context.chatbot, cleanMessage);
     this.context.tdclient.sendSupportMessage(
       this.requestId,
-      message,
+      cleanMessage,
       (err) => {
         if (err) {
           console.error("Error sending reply:", err);
         }
         if (this.log) {console.log("Reply message sent");}
-        const delay = TiledeskChatbotUtil.totalMessageWait(message);
+        const delay = TiledeskChatbotUtil.totalMessageWait(cleanMessage);
         // console.log("got total delay:", delay)
         if (delay > 0 && delay <= 30000) { // prevent long delays
           setTimeout(() => {

package/tiledeskChatbotPlugs/directives/DirSetAttributeV2.js

@@ -0,0 +1,190 @@
+const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
+const { TiledeskExpression } = require('../../TiledeskExpression');
+const { TiledeskMath } = require('../../TiledeskMath');
+const { TiledeskString } = require('../../TiledeskString');
+const { Filler } = require('../Filler');
+const validate = require('jsonschema').validate;
+
+const schema = {
+    "type": "object",
+    "properties": {
+        "_tdActionType": {
+            "type": "string",
+            "enum": ["setattribute"]
+        },
+        "_tdActionId": {
+            "type": ["string", "null"]
+        },
+        "_tdActionTitle": {
+            "type": ["string", "null"]
+        },
+        "destination": {
+            "type": "string",
+        },
+        "operation": {
+            "type": "object",
+            "properties": {
+                "operators": {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                        "enum": ["addAsNumber", "addAsString", "subtractAsNumber", "multiplyAsNumber", "divideAsNumber"]
+                    }
+                },
+
+                "operands": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "value": {
+                                "type": "string"
+                            },
+                            "isVariable": {
+                                "type": "boolean"
+                            },
+                            "function": {
+                                "type": "string",
+                                "enum": ["capitalizeAsString", "upperCaseAsString", "lowerCaseAsString", "absAsNumber", "ceilAsNumber", "floorAsNumber", "roundAsNumber"]
+                            }
+                        },
+                        "required": ["value", "isVariable"],
+                        "additionalProperties": false,
+                        "if": {
+                            "properties": { "isVariable": { "const": true } },
+                        },
+                        "then": {
+                            "properties": { "value": { "pattern": "^[a-zA-Z_]*[.]*[a-zA-Z_]+[a-zA-Z0-9_]*$" } }
+                        }
+                    }
+                }
+            },
+            "required": ["operands"],
+            "additionalProperties": false
+        }
+    },
+    "required": ["_tdActionType", "destination", "operation"],
+    "additionalProperties": false
+};
+
+
+class DirSetAttributeV2 {
+
+    constructor(context) {
+        if (!context) {
+            throw new Error('context object is mandatory.');
+        }
+        this.context = context;
+        this.tdcache = context.tdcache;
+        this.log = context.log;
+    }
+
+    execute(directive, callback) {
+        let action;
+        if (directive.action) {
+            action = directive.action
+        }
+        else {
+            callback();
+            return;
+        }
+        // console.log("go DirAssign with action:", action);
+        this.go(action, () => {
+            callback();
+        });
+    }
+
+    async go(action, callback) {
+        console.log("(DirSetAttribute) action before filling:", JSON.stringify(action));
+        if (action && action.operation && action.operation.operands) {
+            console.log("filling in setattribute...");
+            await this.fillValues(action.operation.operands);
+        }
+        console.log("filled in setattribute:", action.operation);
+        // let res = validate(action, schema);
+        // if (res.errors) {
+        //     console.log("(DirSetAttribute) failed validation action:", JSON.stringify(action));
+        //     console.log("DirSetAttribute validation errors:", res.errors);
+        // }
+        // if (!res.valid) {
+        //     if (this.log) {console.error("(DirSetAttribute) Invalid action:", res.errors)};
+        //     callback();
+        //     return;
+        // }
+        if (action.operation.operators === undefined && action.operation.operands.length !== 1) {
+            if (this.log) {console.error("(DirSetAttribute) Invalid action: operators === undefined && operands.length !== 1")};
+            callback();
+            return;
+        }
+        if (action.operation.operators !== undefined && action.operation.operators.length !== action.operation.operands.length - 1) {
+            if (this.log) {console.error("(DirSetAttribute) Invalid action: operators.length !== operands.length - 1")};
+            callback();
+            return;
+        }
+        // if (action && action.operation && action.operation.operands) {
+        //     console.log("filling in setattribute...");
+        //     await this.fillValues(action.operation.operands);
+        // }
+        console.log("dirsetattribute, action.operation.operands:", action.operation.operands);
+        const expression = TiledeskExpression.JSONOperationToExpression(action.operation.operators, action.operation.operands);
+        const attributes = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
+        console.log("dirsetattribute, attributes:", attributes);
+        attributes.TiledeskMath = TiledeskMath;
+        attributes.TiledeskString = TiledeskString;
+        const result = new TiledeskExpression().evaluateJavascriptExpression(expression, attributes);
+        console.log("filling in setattribute, result:", result);
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.destination, result);
+        callback();
+    }
+
+    async fillValues(operands) {
+        // operation: {
+        //     operators: ["addAsNumber", "subtractAsNumber", "divideAsNumber", "multiplyAsNumber"],
+        //     operands: [
+        //         {
+        //             value: "previous",
+        //             isVariable: true
+        //         },
+        //         {
+        //             value: "temp",
+        //             isVariable: true,
+        //             function: "floorAsNumber"
+        //         },
+        //         {
+        //             value: "real",
+        //             isVariable: true,
+        //             function: "absAsNumber"
+        //         },
+        //         {
+        //             value: "input",
+        //             isVariable: true
+        //         },
+        //         {
+        //             value: "2",
+        //             isVariable: false
+        //         }
+        //     ]
+        try {
+            if (this.tdcache) {
+                // console.log("tdcache in setattribute...", this.tdcache);
+                const requestAttributes = 
+                    await TiledeskChatbot.allParametersStatic(this.tdcache, this.context.requestId);
+                // console.log("requestAttributes in setattribute...", requestAttributes);
+                const filler = new Filler();
+                operands.forEach(operand => {
+                    if (!operand.isVariable) {
+                        console.log("setattribute, liquid operand:", operand);
+                        operand.value = filler.fill(operand.value, requestAttributes);
+                        console.log("setattribute, final operand:", operand);
+                    }
+                });
+            }
+        }
+        catch(error) {
+            console.error("Error while filling operands:", error);
+        }
+    }
+}
+
+module.exports = { DirSetAttributeV2 }; 

package/tiledeskChatbotPlugs/directives/Directives.js

@@ -22,6 +22,7 @@ class Directives {
   static FUNCTION_VALUE = "functionvalue";
   static JSON_CONDITION = "jsoncondition";
   static SET_ATTRIBUTE = "setattribute";
+  static SET_ATTRIBUTE_V2 = "setattribute-v2";
   static REPLY = 'reply';
   static RANDOM_REPLY = 'randomreply';
   static CODE = 'code';