@tiledesk/tiledesk-tybot-connector 0.2.138 → 0.2.139-rc2

package/CHANGELOG.md

@@ -17,10 +17,20 @@ available on:
 - Added flowError on JSONCondition when result = null
 - Added fix on Filler -->
 
+# v0.2.139-rc1
+- Improved ReplaceBotV2
+
 # v0.2.138
 - Bug-fixed: hiddenMessage not blocked
 - Bug-fixed: DirAskGPTV2 has hardcoded engine
 
+# v0.2.138-rc8
+- Updated redis to 4.7.0
+- Updated tdCache
+
+# v0.2.138-rc6
+- First deploy external
+
 # v0.2.138-rc1
 - Updated redis to 4.7.0
 - Updated tdCache

package/TdCache.js

@@ -3,38 +3,63 @@ const redis = require('redis');
 class TdCache {
 
     constructor(config) {
+        console.log("TdCache config: ", config);
         this.redis_host = config.host;
         this.redis_port = config.port;
         this.redis_password = config.password;
+        console.log("TdCache this.redis_host: ", this.redis_host);
+        console.log("TdCache this.redis_port: ", this.redis_port);
+        console.log("TdCache this.redis_password: ", this.redis_password);
         this.client = null;
+        this.redis_sub = null;
     }
 
     async connect(callback) {
-        // client = redis.createClient();
+
         return new Promise( async (resolve, reject) => {
+            /**
+             * Connect redis client
+             */
             this.client = redis.createClient(
-                {
-                    host: this.redis_host,
-                    port: this.redis_port,
-                    password: this.redis_password
-                });
+              {
+                  url: `redis://${this.redis_host}:${this.redis_port}`,
+                  password: this.redis_password
+              });
             this.client.on('error', err => {
                 reject(err);
                 if (callback) {
                     callback(err);
                 }
             });
-            // this.client.on('connect', function() {
-            //     console.log('Redis Connected!');
-            // });
             this.client.on('ready',function() {
-              // console.log("connected")
                 resolve();
                 if (callback) {
                     callback();
                 }
-                //console.log("Redis is ready.");
             });
+            await this.client.connect();
+
+            /**
+             * Connect redis subscription client
+             */
+            this.redis_sub = redis.createClient(
+              {
+                url: `redis://${this.redis_host}:${this.redis_port}`,
+                password: this.redis_password
+              });
+            this.redis_sub.on('error', err => {
+                reject(err);
+                if (callback) {
+                    callback(err);
+                }
+            });
+            this.redis_sub.on('ready',function() {
+                resolve();
+                if (callback) {
+                    callback();
+                }
+            });
+            await this.redis_sub.connect();
         });
     }
 
@@ -43,202 +68,59 @@ class TdCache {
       if (!options) {
         options = {EX: 86400}
       }
-      return new Promise( async (resolve, reject) => {
-        if (options && options.EX) {
-          //console.log("expires:", options.EX)
-          try {
-            this.client.set(
-              key,
-              value,
-              'EX', options.EX,
-              (err) => {
-                if (err) {
-                  reject(err);
-                }
-                else {
-                  return resolve();
-                }
-              }
-            );
-          }
-          catch(error) {
-            reject(error)
-          }
-        }
-        else {
-          try {
-            //console.log("setting here...key", key, value)
-            await this.client.set(
-              key,
-              value,
-              (err) => {
-                if (err) {
-                  reject(err);
-                }
-                else {
-                  return resolve();
-                }
-              }
-            );
-          }
-          catch(error) {
-            console.error("TdCache Error:", error);
-            reject(error)
-          }
-        }
-        // if (options && options.callback) {
-        //     options.callback();
-        // }
-        //console.log("resolving...", key);
-        // return resolve();
-      });
+      await this.client.set(
+        key,
+        value,
+        options);
     }
 
     async incr(key) {
-      // console.log("incr key:", key)
-      return new Promise( async (resolve, reject) => {
-          try {
-            // console.log("incr here...key", key)
-            await this.client.incr(key);
-          }
-          catch(error) {
-            console.error("Error on incr:", error);
-            reject(error)
-          }
-        return resolve();
-      });
+      await this.client.incr(key);
     }
 
     async hset(dict_key, key, value, options) {
-      //console.log("hsetting dict_key key value", dict_key, key, value)
-      return new Promise( async (resolve, reject) => {
-        if (options && options.EX) {
-          //console.log("expires:", options.EX)
-          try {
-            await this.client.hset(
-              dict_key,
-              key,
-              value,
-              'EX', options.EX);
-          }
-          catch(error) {
-            reject(error)
-          }
-        }
-        else {
-          try {
-            //console.log("setting here...key", key, value)
-            await this.client.hset(
-              dict_key,
-              key,
-              value);
-          }
-          catch(error) {
-            console.error("Error", error);
-            reject(error)
-          }
-        }
-        if (options && options.callback) {
-            options.callback();
-        }
-        return resolve();
-      });
+      if (!value) {
+        return;
+      }
+      if (!options) {
+        options = {EX: 86400}
+      }
+      await this.client.HSET(
+        dict_key,
+        key,
+        value,
+        options);
     }
 
-    async hdel(dict_key, key, options) {
-      //console.log("hsetting dict_key key value", dict_key, key, value)
-      return new Promise( async (resolve, reject) => {
-        if (options && options.EX) {
-          //console.log("expires:", options.EX)
-          try {
-            await this.client.hdel(
-              dict_key,
-              key,
-              'EX', options.EX);
-          }
-          catch(error) {
-            reject(error)
-          }
-        }
-        else {
-          try {
-            //console.log("setting here...key", key, value)
-            await this.client.hdel(
-              dict_key,
-              key);
-          }
-          catch(error) {
-            console.error("Error", error);
-            reject(error);
-          }
-        }
-        if (options && options.callback) {
-            options.callback();
-        }
-        return resolve();
-      });
+    async hdel(dict_key, key) {
+      await this.client.HDEL(dict_key, key);
     }
     
     async setJSON(key, value, options) {
+      if (!value) {
+        return;
+      }
+      if (!options) {
+        options = {EX: 86400}
+      }
       const _string = JSON.stringify(value);
       return await this.set(key, _string, options);
     }
     
-    async get(key, callback) {
-      //console.log("getting key", key)
-      return new Promise( async (resolve, reject) => {
-        this.client.get(key, (err, value) => {
-          if (err) {
-            reject(err);
-          }
-          else {
-            if (callback) {
-              callback(value);
-          }
-          return resolve(value);
-          }
-        });
-      });
+    async get(key) {
+      const value = await this.client.GET(key);
+      return value;
     }
 
-    async hgetall(dict_key, callback) {
-      //console.log("hgetting dics", dict_key);
-      return new Promise( async (resolve, reject) => {
-        this.client.hgetall(dict_key, (err, value) => {
-          if (err) {
-            reject(err);
-            if (callback) {
-              callback(err, null);
-            }
-          }
-          else {
-            if (callback) {
-              callback(null, value);
-            }
-            resolve(value);
-          }
-        });
-      });
+    async hgetall(dict_key) {
+      const all = await this.client.HGETALL(dict_key);
+      return all;
     }
 
-    async hget(dict_key, key, callback) {
-      //console.log("hgetting dics", dict_key);
-      return new Promise( async (resolve, reject) => {
-        this.client.hget(dict_key, key, (err, value) => {
-          if (err) {
-            reject(err);
-            if (callback) {
-              callback(err, null);
-            }
-          }
-          else {
-            if (callback) {
-              callback(null, value);
-            }
-            resolve(value);
-          }
-        });
-      });
+    async hget(dict_key, key) {
+      // console.log("hgetting dics", dict_key);
+      const value = await this.client.HGET(dict_key, key);
+      return value;
     }
     
     async getJSON(key, callback) {
@@ -246,16 +128,19 @@ class TdCache {
       return JSON.parse(value);
     }
     
-    async del(key, callback) {
-      return new Promise( async (resolve, reject) => {
-        this.client.del(key, () => {
-          if (callback) {
-            callback();
-          }
-          return resolve();
-        });
-      })
+    async del(key) {
+        await this.client.del(key);
     }
+    
+    async publish(key, value) {
+      await this.redis_sub.publish(key, value);
+    }
+
+    // subscribe(key, callback) {
+    //   this.redis_sub.subscribe(key, (message) => {
+    //     callback(message);
+    //   });
+    // }
 }
 
 module.exports = { TdCache };

package/TdCache_v3.js

@@ -0,0 +1,261 @@
+const redis = require('redis');
+
+class TdCache {
+
+    constructor(config) {
+        this.redis_host = config.host;
+        this.redis_port = config.port;
+        this.redis_password = config.password;
+        this.client = null;
+    }
+
+    async connect(callback) {
+        // client = redis.createClient();
+        return new Promise( async (resolve, reject) => {
+            this.client = redis.createClient(
+                {
+                    host: this.redis_host,
+                    port: this.redis_port,
+                    password: this.redis_password
+                });
+            this.client.on('error', err => {
+                reject(err);
+                if (callback) {
+                    callback(err);
+                }
+            });
+            // this.client.on('connect', function() {
+            //     console.log('Redis Connected!');
+            // });
+            this.client.on('ready',function() {
+              // console.log("connected")
+                resolve();
+                if (callback) {
+                    callback();
+                }
+                //console.log("Redis is ready.");
+            });
+        });
+    }
+
+    async set(key, value, options) {
+      //console.log("setting key value", key, value)
+      if (!options) {
+        options = {EX: 86400}
+      }
+      return new Promise( async (resolve, reject) => {
+        if (options && options.EX) {
+          //console.log("expires:", options.EX)
+          try {
+            this.client.set(
+              key,
+              value,
+              'EX', options.EX,
+              (err) => {
+                if (err) {
+                  reject(err);
+                }
+                else {
+                  return resolve();
+                }
+              }
+            );
+          }
+          catch(error) {
+            reject(error)
+          }
+        }
+        else {
+          try {
+            //console.log("setting here...key", key, value)
+            await this.client.set(
+              key,
+              value,
+              (err) => {
+                if (err) {
+                  reject(err);
+                }
+                else {
+                  return resolve();
+                }
+              }
+            );
+          }
+          catch(error) {
+            console.error("TdCache Error:", error);
+            reject(error)
+          }
+        }
+        // if (options && options.callback) {
+        //     options.callback();
+        // }
+        //console.log("resolving...", key);
+        // return resolve();
+      });
+    }
+
+    async incr(key) {
+      // console.log("incr key:", key)
+      return new Promise( async (resolve, reject) => {
+          try {
+            // console.log("incr here...key", key)
+            await this.client.incr(key);
+          }
+          catch(error) {
+            console.error("Error on incr:", error);
+            reject(error)
+          }
+        return resolve();
+      });
+    }
+
+    async hset(dict_key, key, value, options) {
+      //console.log("hsetting dict_key key value", dict_key, key, value)
+      return new Promise( async (resolve, reject) => {
+        if (options && options.EX) {
+          //console.log("expires:", options.EX)
+          try {
+            await this.client.hset(
+              dict_key,
+              key,
+              value,
+              'EX', options.EX);
+          }
+          catch(error) {
+            reject(error)
+          }
+        }
+        else {
+          try {
+            //console.log("setting here...key", key, value)
+            await this.client.hset(
+              dict_key,
+              key,
+              value);
+          }
+          catch(error) {
+            console.error("Error", error);
+            reject(error)
+          }
+        }
+        if (options && options.callback) {
+            options.callback();
+        }
+        return resolve();
+      });
+    }
+
+    async hdel(dict_key, key, options) {
+      //console.log("hsetting dict_key key value", dict_key, key, value)
+      return new Promise( async (resolve, reject) => {
+        if (options && options.EX) {
+          //console.log("expires:", options.EX)
+          try {
+            await this.client.hdel(
+              dict_key,
+              key,
+              'EX', options.EX);
+          }
+          catch(error) {
+            reject(error)
+          }
+        }
+        else {
+          try {
+            //console.log("setting here...key", key, value)
+            await this.client.hdel(
+              dict_key,
+              key);
+          }
+          catch(error) {
+            console.error("Error", error);
+            reject(error);
+          }
+        }
+        if (options && options.callback) {
+            options.callback();
+        }
+        return resolve();
+      });
+    }
+    
+    async setJSON(key, value, options) {
+      const _string = JSON.stringify(value);
+      return await this.set(key, _string, options);
+    }
+    
+    async get(key, callback) {
+      //console.log("getting key", key)
+      return new Promise( async (resolve, reject) => {
+        this.client.get(key, (err, value) => {
+          if (err) {
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(value);
+          }
+          return resolve(value);
+          }
+        });
+      });
+    }
+
+    async hgetall(dict_key, callback) {
+      //console.log("hgetting dics", dict_key);
+      return new Promise( async (resolve, reject) => {
+        this.client.hgetall(dict_key, (err, value) => {
+          if (err) {
+            reject(err);
+            if (callback) {
+              callback(err, null);
+            }
+          }
+          else {
+            if (callback) {
+              callback(null, value);
+            }
+            resolve(value);
+          }
+        });
+      });
+    }
+
+    async hget(dict_key, key, callback) {
+      //console.log("hgetting dics", dict_key);
+      return new Promise( async (resolve, reject) => {
+        this.client.hget(dict_key, key, (err, value) => {
+          if (err) {
+            reject(err);
+            if (callback) {
+              callback(err, null);
+            }
+          }
+          else {
+            if (callback) {
+              callback(null, value);
+            }
+            resolve(value);
+          }
+        });
+      });
+    }
+    
+    async getJSON(key, callback) {
+      const value = await this.get(key);
+      return JSON.parse(value);
+    }
+    
+    async del(key, callback) {
+      return new Promise( async (resolve, reject) => {
+        this.client.del(key, () => {
+          if (callback) {
+            callback();
+          }
+          return resolve();
+        });
+      })
+    }
+}
+
+module.exports = { TdCache };

package/index.js

@@ -609,6 +609,7 @@ router.post('/block/:project_id/:bot_id/:block_id', async (req, res) => {
 
 async function startApp(settings, completionCallback) {
   console.log("Starting Tilebot...");
+  // console.log("Starting Tilebot with Settings:", settings);
   if (settings.bots) { // static bots data source
     staticBots = settings.bots;
   }

package/models/TiledeskChatbotUtil.js

@@ -699,7 +699,6 @@ class TiledeskChatbotUtil {
                 await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_ID_KEY, message.attributes.departmentId);
                 await chatbot.addParameter(TiledeskChatbotConst.REQ_DEPARTMENT_NAME_KEY, message.attributes.departmentName);
             }
-
             if (message.attributes) {
                 if (chatbot.log) {console.log("Ok message.attributes", JSON.stringify(message.attributes));}
                 // if (projectId === "641864da99c1fb00131ba495") {console.log("641864da99c1fb00131ba495 > Ok message.attributes", JSON.stringify(message.attributes));}
@@ -920,6 +919,7 @@ class TiledeskChatbotUtil {
     }
 
     /**
+     * DEPRECATED
      * A stub to get the request parameters, hosted by tilebot on:
      * /${TILEBOT_ROUTE}/ext/parameters/requests/${requestId}?all
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.2.138",
+  "version": "0.2.139-rc2",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {
@@ -29,7 +29,7 @@
     "mongoose": "^6.3.5",
     "multer": "^1.4.5-lts.1",
     "nanoid": "^3.1.25",
-    "redis": "^3.1.2",
+    "redis": "^4.7.0",
     "uuid": "^3.3.3",
     "vm2": "^3.9.13"
   },

package/tiledeskChatbotPlugs/directives/DirReplaceBotV2.js

@@ -2,6 +2,9 @@ const { TiledeskClient } = require('@tiledesk/tiledesk-client');
 const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
 const { Filler } = require('../Filler');
 
+const axios = require("axios").default;
+let https = require("https");
+
 class DirReplaceBotV2 {
 
   constructor(context) {
@@ -52,30 +55,125 @@ class DirReplaceBotV2 {
     );
     const filler = new Filler();
     botName = filler.fill(botName, variables);
-    this.tdClient.replaceBotByName(this.requestId, botName, () => {
-      if (blockName) {
-        if (this.log) {console.log("Sending hidden /start message to bot in dept");}
-        const message = {
-          type: "text",
-          text: "/" + blockName,
-          attributes : {
-            subtype: "info"
+
+    const HTTPREQUEST = {
+      url: this.API_ENDPOINT + "/" + this.context.projectId + "/requests/" + this.requestId + "/replace",
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': 'JWT ' + this.context.token
+      },
+      json: { name: botName},
+      method: 'PUT'
+    }
+
+    this.#myrequest(
+      HTTPREQUEST, async (err, resbody) => {
+        if (err) {
+          console.log("DirReplaceBot error: ", err);
+          if (callback) {
+            callback();
+            return;
           }
         }
-        this.tdClient.sendSupportMessage(
-          this.requestId,
-          message, (err) => {
-            if (err) {
-              console.error("Error sending hidden message:", err.message);
+
+        if (this.log) { console.log("DirReplaceBot replace resbody: ", resbody) };
+        if (blockName) {
+          if (this.log) { console.log("Sending hidden /start message to bot in dept"); }
+          const message = {
+            type: "text",
+            text: "/" + blockName,
+            attributes: {
+              subtype: "info"
             }
-            if (this.log) {console.log("Hidden message sent.");}
-            callback();
-        });
-      }
-      else {
-        callback();
+          }
+          this.tdClient.sendSupportMessage(
+            this.requestId,
+            message, (err) => {
+              if (err) {
+                console.error("Error sending hidden message:", err.message);
+              }
+              if (this.log) { console.log("Hidden message sent."); }
+              callback();
+            });
+        }
+        else {
+          callback();
+        }
       }
-    });
+    )
+
+    // this.tdClient.replaceBotByName(this.requestId, botName, () => {
+    //   if (blockName) {
+    //     if (this.log) {console.log("Sending hidden /start message to bot in dept");}
+    //     const message = {
+    //       type: "text",
+    //       text: "/" + blockName,
+    //       attributes : {
+    //         subtype: "info"
+    //       }
+    //     }
+    //     this.tdClient.sendSupportMessage(
+    //       this.requestId,
+    //       message, (err) => {
+    //         if (err) {
+    //           console.error("Error sending hidden message:", err.message);
+    //         }
+    //         if (this.log) {console.log("Hidden message sent.");}
+    //         callback();
+    //     });
+    //   }
+    //   else {
+    //     callback();
+    //   }
+    // });
+  }
+
+  #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 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("(DirAskGPT) Axios error: ", JSON.stringify(error));
+        if (callback) {
+          callback(error, null);
+        }
+      });
   }
 }
 

package/TdCache_v4.js

@@ -1,146 +0,0 @@
-const redis = require('redis');
-
-class TdCache {
-
-    constructor(config) {
-        console.log("TdCache config: ", config);
-        this.redis_host = config.host;
-        this.redis_port = config.port;
-        this.redis_password = config.password;
-        console.log("TdCache this.redis_host: ", this.redis_host);
-        console.log("TdCache this.redis_port: ", this.redis_port);
-        console.log("TdCache this.redis_password: ", this.redis_password);
-        this.client = null;
-        this.redis_sub = null;
-    }
-
-    async connect(callback) {
-
-        return new Promise( async (resolve, reject) => {
-            /**
-             * Connect redis client
-             */
-            this.client = redis.createClient(
-                {
-                    url: `redis://${this.redis_host}:${this.redis_port}`,
-                    password: this.redis_password
-                });
-            this.client.on('error', err => {
-                reject(err);
-                if (callback) {
-                    callback(err);
-                }
-            });
-            this.client.on('ready',function() {
-                resolve();
-                if (callback) {
-                    callback();
-                }
-            });
-            await this.client.connect();
-
-            /**
-             * Connect redis subscription client
-             */
-            this.redis_sub = redis.createClient(
-              {
-                url: `redis://${this.redis_host}:${this.redis_port}`,
-                password: this.redis_password
-              });
-            this.redis_sub.on('error', err => {
-                reject(err);
-                if (callback) {
-                    callback(err);
-                }
-            });
-            this.redis_sub.on('ready',function() {
-                resolve();
-                if (callback) {
-                    callback();
-                }
-            });
-            await this.redis_sub.connect();
-        });
-    }
-
-    async set(key, value, options) {
-      //console.log("setting key value", key, value)
-      if (!options) {
-        options = {EX: 86400}
-      }
-      await this.client.set(
-        key,
-        value,
-        options);
-    }
-
-    async incr(key) {
-      await this.client.incr(key);
-    }
-
-    async hset(dict_key, key, value, options) {
-      if (!value) {
-        return;
-      }
-      if (!options) {
-        options = {EX: 86400}
-      }
-      await this.client.HSET(
-        dict_key,
-        key,
-        value,
-        options);
-    }
-
-    async hdel(dict_key, key) {
-      await this.client.HDEL(dict_key, key);
-    }
-    
-    async setJSON(key, value, options) {
-      if (!value) {
-        return;
-      }
-      if (!options) {
-        options = {EX: 86400}
-      }
-      const _string = JSON.stringify(value);
-      return await this.set(key, _string, options);
-    }
-    
-    async get(key) {
-      const value = await this.client.GET(key);
-      return value;
-    }
-
-    async hgetall(dict_key) {
-      const all = await this.client.HGETALL(dict_key);
-      return all;
-    }
-
-    async hget(dict_key, key) {
-      // console.log("hgetting dics", dict_key);
-      const value = await this.client.HGET(dict_key, key);
-      return value;
-    }
-    
-    async getJSON(key, callback) {
-      const value = await this.get(key);
-      return JSON.parse(value);
-    }
-    
-    async del(key) {
-        await this.client.del(key);
-    }
-    
-    async publish(key, value) {
-      await this.redis_sub.publish(key, value);
-    }
-
-    // subscribe(key, callback) {
-    //   this.redis_sub.subscribe(key, (message) => {
-    //     callback(message);
-    //   });
-    // }
-}
-
-module.exports = { TdCache };