@tiledesk/tiledesk-tybot-connector 0.2.27 → 0.2.29

package/CHANGELOG.md

@@ -5,6 +5,14 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+### v0.2.29
+- Added Make action 
+
+### 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

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/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/TiledeskChatbotUtil.js

@@ -518,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.27",
+  "version": "0.2.29",
   "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');
@@ -39,6 +40,7 @@ const { DirRandomReply } = require('./directives/DirRandomReply');
 const { DirGptTask } = require('./directives/DirGptTask');
 const { DirForm } = require('./directives/DirForm');
 const { DirCaptureUserReply } = require('./directives/DirCaptureUserReply');
+const { DirMake } = require('./directives/DirMake');
 
 class DirectivesChatbotPlug {
 
@@ -370,6 +372,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(
@@ -601,6 +610,12 @@ class DirectivesChatbotPlug {
         this.process(next_dir);
       })
     }
+    else if (directive_name === Directives.MAKE) {
+      new DirMake(context).execute(directive, async () => {
+        let next_dir = await this.nextDirective(this.directives);
+        this.process(next_dir);
+      })
+    }
     else {
       //console.log("Unhandled Post-message Directive:", directive_name);
       let next_dir = await this.nextDirective(this.directives);

package/tiledeskChatbotPlugs/directives/DirMake.js

@@ -0,0 +1,257 @@
+const axios = require("axios").default;
+const { TiledeskChatbot } = require("../../models/TiledeskChatbot");
+const { Filler } = require("../Filler");
+const { DirIntent } = require("./DirIntent");
+let https = require("https");
+require('dotenv').config();
+
+
+class DirMake {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory');
+    }
+    this.context = context;
+    this.tdcache = this.context.tdcache;
+    this.requestId = this.context.requestId;
+    this.log = context.log;
+    this.intentDir = new DirIntent(context);
+  }
+
+  execute(directive, callback) {
+    if (this.log) { console.log("DirMake directive: ", directive); }
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("DirMake Incorrect directive: ", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, () => {
+      callback();
+    })
+  }
+
+  async go(action, callback) {
+    if (this.log) { console.log("DirMake action:", JSON.stringify(action)); }
+    if (!this.tdcache) {
+      console.error("Error: DirMake tdcache is mandatory");
+      callback();
+      return;
+    }
+    //console.log('DirMake work!');
+    let requestVariables = null;
+    requestVariables =
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      )
+
+    if (this.log) {
+      const all_parameters = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
+      for (const [key, value] of Object.entries(all_parameters)) {
+        if (this.log) { console.log("DirMake request parameter:", key, "value:", value, "type:", typeof value) }
+      }
+    }
+
+    let webhook_url = action.url;
+    let bodyParameters = action.bodyParameters;
+    if (this.log) {
+      console.log("DirMake webhook_url: ", webhook_url);
+      console.log("DirMake bodyParameters: ", bodyParameters);
+    }
+    if (!bodyParameters || bodyParameters === '') {
+      console.error("DirMake ERROR - bodyParameters is undefined or null or empty string");
+      callback();
+      return;
+    }
+    if (!webhook_url || webhook_url === '') {
+      console.error("DirMake ERROR - webhook_url is undefined or null or empty string");
+      callback();
+      return;
+    }
+    let url;
+    try {
+    console.log('CIAOkkkk',bodyParameters)
+    let make_base_url = process.env.MAKE_ENDPOINT;
+    if (make_base_url) {
+      url = make_base_url + "/make/";
+    } else {
+      url = action.url;
+    }
+    console.log('Make url: ', url);
+    const filler = new Filler();
+
+    
+      for (const [key, value] of Object.entries(bodyParameters)) {
+        if (this.log) {console.log("bodyParam:", key, "value:", value)}
+        let filled_value = filler.fill(value, requestVariables);
+        bodyParameters[key] = filled_value;
+      }
+    
+      console.log('CIAO',bodyParameters)
+    
+
+
+    
+    // Condition branches
+    let trueIntent = action.trueIntent;
+    let falseIntent = action.falseIntent;
+    console.log('trueIntent',trueIntent)
+ 
+    if (this.log) { console.log("DirMake MakeEndpoint URL: ", make_base_url); }
+    const MAKE_HTTPREQUEST = {
+      url: url,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      json: bodyParameters,
+      method: "POST"
+    }
+  
+    if (this.log) { console.log("myrequest/DirMake MAKE_HTTPREQUEST", MAKE_HTTPREQUEST); }
+    this.#myrequest(
+      MAKE_HTTPREQUEST, async (err, resbody) => {
+        if (err) {
+          if (callback) {
+            console.error("myrequest/(httprequest) DirMake make err:", err);
+            let status = 404;   
+            let error = 'Not found';
+            await this.#assignAttributes(action, status, error);
+            this.#executeCondition(false, trueIntent, null, falseIntent, null, () => {
+              callback(false); // continue the flow
+            });
+            callback();
+          }
+        } else if (callback) {
+          if (this.log) { console.log("myrequest/DirMake Make resbody: ", resbody); }
+          let status = 200;   
+          let error = null;
+          await this.#assignAttributes(action, status, error); 
+          await this.#executeCondition(true, trueIntent, null, falseIntent, null, () => {
+            callback(); // stop the flow
+          });
+          console.log('myrequest/status: ',status)
+          callback();
+        }
+      }
+    );
+  } catch(e) {
+    console.error('error: ', e)
+  }
+  }
+
+  async #assignAttributes(action, status, error) {
+    if (this.log) {
+      console.log("DirMake assignAttributes action:", action)
+      console.log("DirMake assignAttributes status:", status)
+      console.log("DirMake assignAttributes error:", error)
+    }
+    if (this.context.tdcache) {
+      if (action.assignStatusTo) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignStatusTo, status);
+      }
+      if (action.assignErrorTo) {
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignErrorTo, error);
+      }
+
+      // Debug log
+      if (this.log) {
+        const all_parameters = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
+        for (const [key, value] of Object.entries(all_parameters)) {
+          if (this.log) { console.log("DirMake request parameter:", key, "value:", value, "type:", typeof value) }
+        }
+      }
+    }
+  }
+
+  #myrequest(options, callback) {
+    if (this.log) {
+      console.log("API URL:", options.url);
+      console.log("** Options:", JSON.stringify(options));
+    }
+    let axios_options = {
+      url: options.url,
+      method: options.method,
+      params: options.params,
+      headers: options.headers
+    }
+    if (options.json !== null) {
+      axios_options.data = options.json
+    }
+    if (this.log) {
+      console.log("axios_options:", JSON.stringify(axios_options));
+    }
+    if (options.url.startsWith("https:")) {
+      const httpsAgent = new https.Agent({
+        rejectUnauthorized: false,
+      });
+      axios_options.httpsAgent = httpsAgent;
+    }
+    axios(axios_options)
+      .then((res) => {
+        if (this.log) {
+          console.log("Response for url:", options.url);
+          console.log("Response status:", res.status);
+          console.log("Response headers:\n", JSON.stringify(res.headers));
+        }
+        if (res && res.status == 200 && res.data) {
+          if (callback) {
+            callback(null, res.data);
+          }
+        }
+        else {
+          if (callback) {
+            callback(new Error("Response status is not 200"), null);
+          }
+        }
+      })
+      .catch((error) => {
+        // console.error("An error occurred:", JSON.stringify(error.data));
+        if (callback) {
+          callback(error, null);
+        }
+      });
+  }
+  async #executeCondition(result, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, callback) {
+    let trueIntentDirective = null;
+   
+    if (trueIntent) {
+      //console.log('executeCondition/trueIntent',trueIntent)
+      trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent, trueIntentAttributes);
+      //console.log('executeCondition/trueIntentDirective',trueIntentDirective)
+      //console.log('executeCondition/trueIntentAttributes',trueIntentAttributes)
+    }
+    let falseIntentDirective = null;
+    if (falseIntent) {
+      falseIntentDirective = DirIntent.intentDirectiveFor(falseIntent, falseIntentAttributes);
+    }
+    if (this.log) {console.log('DirMake executeCondition/result',result)}
+    if (result === true) {
+      if (trueIntentDirective) {
+        this.intentDir.execute(trueIntentDirective, () => {
+          callback();
+        });
+      }
+      else {
+        if (this.log) {console.log("No trueIntentDirective specified");}
+        callback();
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.intentDir.execute(falseIntentDirective, () => {
+          callback();
+        });
+      }
+      else {
+        if (this.log) {console.log("No falseIntentDirective specified");}
+        callback();
+      }
+    }
+  }
+}
+
+module.exports = { DirMake }

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';
@@ -31,6 +32,7 @@ class Directives {
   static FORM = "form";
   static CAPTURE_USER_REPLY = "capture_user_reply";
   static QAPLA = 'qapla';
+  static MAKE = 'make';
 
   // static WHEN_ONLINE_MOVE_TO_AGENT = "whenonlinemovetoagent"; // DEPRECATED?
   // static WHEN_OFFLINE_HOURS = "whenofflinehours"; // DEPRECATED // adds a message on top of the original message when offline hours opts: --replace