@tiledesk/tiledesk-tybot-connector 0.1.89 → 0.1.91

package/CHANGELOG.md

@@ -5,10 +5,19 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
+### 0.1.91
+- Added control for attribute_value null in DirWhatsappByAttribute
+
+### 0.1.90
+- Added support for JSON/Number/string parameters in /intent[] invocation
+- Added support for JSON/Number/string parameters in attributes.payload invocation
+- Added DirWhatsappByAttribute
+- Test external process.env (PASSED)
+
 ### 0.1.89
 - DirWebRequest: fixed sending data: 'null'
 - Improved MockBotsDataSource.js to support search also by intent_id
-- Added test for qapla WebRequest
+- Added test for Qapla WebRequest
 
 ### 0.1.88
 - Added language parse with accept-language-parser. Now user_language has just the first language ISO code

package/index.js

@@ -299,7 +299,8 @@ async function updateRequestVariables(chatbot, message, projectId, requestId) {
           // const value = all_parameters[key];
           const value_type = typeof value;
           //if (projectId === "641864da99c1fb00131ba495") {console.log("641864da99c1fb00131ba495 > importing payload parameter:", key, "value:", value, "type:", value_type);}
-          await chatbot.addParameter(key, String(value));
+          //await chatbot.addParameter(key, String(value));
+          await chatbot.addParameter(key, value);
         }
       }
       catch(err) {

package/models/TiledeskChatbot.js

@@ -181,9 +181,25 @@ class TiledeskChatbot {
               console.log("Got a reply (faq) by Intent name:", JSON.stringify(faq));}
             try {
               if (intent.parameters) {
+                if (this.log) {
+                  for (const [key, value] of Object.entries(intent.parameters)) {
+                    console.log(`* Attribute from intent: '${key}' => ${value}`);             
+                  }
+                }
                 for (const [key, value] of Object.entries(intent.parameters)) {
-                  if (this.log) {console.log(`Adding parameter from intent => ${key}: ${value}`);}
-                  this.addParameter(key, value);
+                  if (this.log) {console.log(`Adding attribute from intent invocation /intentName{} => ${key}: ${value}`);}
+                  // const parameter_typeof_key = "_tdTypeOf:" + key;
+                  // console.log("intent[parameter_typeof_key]",parameter_typeof_key, intent.parameters[parameter_typeof_key]);
+                  // if (intent.parameters[parameter_typeof_key] === "object") {
+                    // const parameter_value_string = JSON.stringify(value)
+                    // console.log("Adding parameter as string:", parameter_value_string)
+                    this.addParameter(key, value);
+                    //this.addParameter(parameter_typeof_key, intent[parameter_typeof_key]);
+                  // }
+                  // else { // TODO: support the other data types
+                  //   this.addParameter(key, value);
+                  // }
+                  
                 }
               }
               reply = await this.execIntent(faq, message, lead);
@@ -504,19 +520,56 @@ class TiledeskChatbot {
   }
 
   async addParameter(parameter_name, parameter_value) {
-    //await this.tdcache.hset("tilebot:requests:" + requestId + ":parameters", parameter_name, parameter_value);
     await TiledeskChatbot.addParameterStatic(this.tdcache, this.requestId, parameter_name, parameter_value);
   }
 
   async deleteParameter(parameter_name) {
-    //await this.tdcache.hset("tilebot:requests:" + requestId + ":parameters", parameter_name, parameter_value);
     await TiledeskChatbot.deleteParameterStatic(this.tdcache, this.requestId, parameter_name);
   }
 
   static async addParameterStatic(_tdcache, requestId, parameter_name, parameter_value) {
-    // const parameter_key = "tilebot:requests:" + requestId + ":parameters";
     const parameter_key = TiledeskChatbot.requestCacheKey(requestId) + ":parameters";
-    await _tdcache.hset(parameter_key, parameter_name, parameter_value);
+    const parameter_value_s = JSON.stringify(parameter_value);
+    await _tdcache.hset(parameter_key, parameter_name, parameter_value_s);
+  }
+
+  async allParameters() {
+    return await TiledeskChatbot.allParametersStatic(this.tdcache, this.requestId);
+  }
+
+  static async allParametersStatic(_tdcache, requestId) {
+    // const parameters_key = "tilebot:requests:" + requestId + ":parameters";
+    const attributes__as_string_map = await _tdcache.hgetall(
+      TiledeskChatbot.requestCacheKey(requestId) + ":parameters");
+    let attributes_native_values = {};
+    for (const [key, value] of Object.entries(attributes__as_string_map)) {
+      attributes_native_values[key] = JSON.parse(value);
+    }
+    return attributes_native_values;
+  }
+
+  async allParametersInstance(_tdcache, requestId) {
+    // const parameters_key = "tilebot:requests:" + requestId + ":parameters";
+    return await _tdcache.hgetall(
+      TiledeskChatbot.requestCacheKey(requestId) + ":parameters");
+  }
+
+  static async getParameterStatic(_tdcache, requestId, key) {
+    // const parameters_key = "tilebot:requests:" + requestId + ":parameters";
+    let value = await _tdcache.hget(
+      TiledeskChatbot.requestCacheKey(requestId) + ":parameters", key);
+    try {
+      value = JSON.parse(value);
+    }
+    catch(error) {
+      console.log("Error parsing to JSON an Attribute:", error);
+    }
+    return value;
+  }
+
+  static async deleteParameterStatic(_tdcache, requestId, paramName) {
+    return await _tdcache.hdel(
+      TiledeskChatbot.requestCacheKey(requestId) + ":parameters", paramName);
   }
 
   static async checkStep(_tdcache, requestId, max_steps, log) {
@@ -573,33 +626,6 @@ class TiledeskChatbot {
     return await _tdcache.get(parameter_key);
   }
 
-  async allParameters() {
-    return await TiledeskChatbot.allParametersStatic(this.tdcache, this.requestId);
-  }
-
-  static async allParametersStatic(_tdcache, requestId) {
-    // const parameters_key = "tilebot:requests:" + requestId + ":parameters";
-    return await _tdcache.hgetall(
-      TiledeskChatbot.requestCacheKey(requestId) + ":parameters");
-  }
-
-  async allParametersInstance(_tdcache, requestId) {
-    // const parameters_key = "tilebot:requests:" + requestId + ":parameters";
-    return await _tdcache.hgetall(
-      TiledeskChatbot.requestCacheKey(requestId) + ":parameters");
-  }
-
-  static async getParameterStatic(_tdcache, requestId, key) {
-    // const parameters_key = "tilebot:requests:" + requestId + ":parameters";
-    return await _tdcache.hget(
-      TiledeskChatbot.requestCacheKey(requestId) + ":parameters", key);
-  }
-
-  static async deleteParameterStatic(_tdcache, requestId, paramName) {
-    return await _tdcache.hdel(
-      TiledeskChatbot.requestCacheKey(requestId) + ":parameters", paramName);
-  }
-
   static requestCacheKey(requestId) {
     const request_key = "tilebot:requests:" + requestId;
     return request_key;

package/models/TiledeskChatbotUtil.js

@@ -23,13 +23,34 @@ class TiledeskChatbotUtil {
             // console.log("json_string (params)", json_string);
             try {
                 intent.parameters = JSON.parse(json_string);
+                // if (intent.parameters) {
+                    // for (const [key, value] of Object.entries(intent.parameters)) {
+                        // console.log("Checking type of:", key, value);
+                    //   if (typeof value === "object") {
+                    //     console.log("Checking type of is object:", key);
+                    //     intent.parameters["_tdTypeOf:" + key] = "object";
+                    //   }
+                    //   else if (typeof value === "string") {
+                    //     console.log("Checking type of is string:", key);
+                    //     intent.parameters["_tdTypeOf:" + key] = "string";
+                    //   }
+                    //   else if (typeof value === "number") {
+                    //     console.log("Checking type of is number:", key);
+                    //     intent.parameters["_tdTypeOf:" + key] = "number";
+                    //   }
+                    //   else if (typeof value === "boolean") {
+                    //     console.log("Checking type of is boolean:", key);
+                    //     intent.parameters["_tdTypeOf:" + key] = "boolean";
+                    //   }
+                    // }
+                //   }
+                
             }
             catch (err) {
                 console.log("error on intent.parameters = JSON.parse(json_string)", err);
-            }            
+            }
         }
         return intent;
-
     }
 
     static chooseRandomReply(message) {

package/package.json

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

package/tiledeskChatbotPlugs/DirectivesChatbotPlug.js

@@ -27,6 +27,7 @@ const { DirAssign } = require('./directives/DirAssign');
 const { DirSetAttribute } = require('./directives/DirSetAttribute');
 const { DirWebRequest } = require('./directives/DirWebRequest');
 const { DirCode } = require('./directives/DirCode');
+const { DirWhatsappByAttribute } = require('./directives/DirWhatsappByAttribute');
 
 const { TiledeskChatbot } = require('../models/TiledeskChatbot');
 const { DirIfOnlineAgents } = require('./directives/DirIfOnlineAgents');
@@ -501,6 +502,12 @@ class DirectivesChatbotPlug {
         }
       });
     }
+    else if (directive_name === Directives.WHATSAPP_ATTRIBUTE) {
+      new DirWhatsappByAttribute(context).execute(directive, async (stop) => {
+        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/DirCode.js

@@ -66,10 +66,11 @@ class DirCode {
       // console.log("script_context.tiledeskVars:", script_context.tiledeskVars);
       for (const [key, value] of Object.entries(script_context.tiledeskVars.ops.set)) {
         // await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, key, value);
-        await variablesManager.set(key, value);
+        // await variablesManager.set(key, value);
+        await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, key, value);
       }
       // if (this.log) {
-        let newvars_set = await variablesManager.all();
+        // let newvars_set = await variablesManager.all();
         // console.log("newvars_set:", newvars_set);
       // }
       for (const [key, value] of Object.entries(script_context.tiledeskVars.ops.del)) {

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -75,6 +75,7 @@ class DirReply {
       if (this.log) {console.log("message before filters:", JSON.stringify(message));}
       if (message.attributes && message.attributes.commands) {
         if (this.log) {console.log("filterOnVariables...on commands", JSON.stringify(message.attributes.commands));}
+        if (this.log) {console.log("filterOnVariables...on attributes", requestAttributes);}
         // TiledeskChatbotUtil.filterOnVariables(message.attributes.commands, requestAttributes);
         TiledeskChatbotUtil.filterOnVariables(message, requestAttributes);
       }

package/tiledeskChatbotPlugs/directives/DirWhatsappByAttribute.js

@@ -0,0 +1,123 @@
+const axios = require("axios").default;
+const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
+
+// const whatsapp_api_url = "https://tiledesk-whatsapp-app-pre.giovannitroisi3.repl.co/ext"
+let whatsapp_api_url;
+
+class DirWhatsappByAttribute {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory');
+    }
+    this.context = context;
+    this.log = context.log;
+  }
+
+  execute(directive, callback) {
+    console.log("\n\nwhatsapp by attribtues action (execute) - directive: ", directive);
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("Incorrect directive: ", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, () => {
+      callback();
+    })
+  }
+
+  async go(action, callback) {
+    if (this.log) {
+      console.log("whatsapp by attributes action: ", JSON.stringify(action))
+    }
+
+    if (process.env.API_URL) {
+      whatsapp_api_url = process.env.API_URL + "/modules/whatsapp";
+      console.log("(Tilebot) DirWhatsappByAttribute whatsapp_api_url: ", whatsapp_api_url);
+    } else {
+      console.error("(Tilebot) ERROR Missing whatsapp_api_url. Unable to use action WhatsApp By Attributes");
+      callback();
+      return;
+    }
+
+    if (action.attributeName) {
+      if (this.log) { console.log("whatsapp attributeName:", action.attributeName); }
+      let attribute_value = null;
+      if (this.context.tdcache) {
+
+        const attribute_value = await TiledeskChatbot.getParameterStatic(this.context.tdcache, this.context.requestId, action.attributeName)
+        if (this.log) { console.log("attribute_value:", JSON.stringify(attribute_value)); }
+
+        if (attribute_value == null) {
+          console.error("(Tilebot) attribute_value is undefined");
+          callback();
+          return;
+        }
+
+        const URL = whatsapp_api_url + '/tiledesk/broadcast';
+        const HTTPREQUEST = {
+          url: URL,
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          json: attribute_value,
+          method: 'POST'
+        };
+        let promise = new Promise((resolve, reject) => {
+          DirWhatsappByAttribute.myrequest(
+            HTTPREQUEST,
+            function (err, resbody) {
+              if (err) {
+                if (callback) {
+                  callback(err);
+                }
+                reject(err);
+              }
+              else {
+                if (callback) {
+                  callback(null, resbody);
+                }
+                console.log("(tybot) broadcast sent: ", resbody);
+                resolve(resbody);
+              }
+            }, true);
+        })
+        return promise;
+      }
+    }
+  }
+
+  // HTTP REQUEST
+  static async myrequest(options, callback, log) {
+    console.log("my request execution")
+    return await axios({
+      url: options.url,
+      method: options.method,
+      data: options.json,
+      params: options.params,
+      headers: options.headers
+    }).then((res) => {
+      if (res && res.status == 200 && res.data) {
+        if (callback) {
+          callback(null, res.data);
+        }
+      }
+      else {
+        if (callback) {
+          callback(TiledeskClient.getErr({ message: "Response status not 200" }, options, res), null, null);
+        }
+      }
+    }).catch((err) => {
+      console.error("(tybot request) An error occured: ", err);
+      if (callback) {
+        callback(err, null, null);
+      }
+    })
+  }
+}
+
+module.exports = { DirWhatsappByAttribute }

package/tiledeskChatbotPlugs/directives/Directives.js

@@ -24,6 +24,7 @@ class Directives {
   static REPLY = 'reply';
   static RANDOM_REPLY = 'randomreply';
   static CODE = 'code';
+  static WHATSAPP_ATTRIBUTE = 'whatsapp_attribute';
 
   // 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