@tiledesk/tiledesk-tybot-connector 0.2.133 → 0.2.135

package/CHANGELOG.md

@@ -17,6 +17,14 @@ available on:
 - Added flowError on JSONCondition when result = null
 - Added fix on Filler -->
 
+# v0.2.135
+- Updated to redis 4.7.0 + Tdcache.js
+- Disabled close_directive_test.js - DirClose directive - too old, not passing
+- Disabled conversation-gpt_assistant_test.js
+
+# v0.2.134
+- Added filter for mweb on hidden messages
+
 # v0.2.133
 - Removed MAX_STEPS and MAX_EXECUTION_TIME as static variable of TiledeskChatbot
 

package/TdCache.js

@@ -7,6 +7,7 @@ class TdCache {
         this.redis_port = config.port;
         this.redis_password = config.password;
         this.client = null;
+        this.redis_sub = null;
     }
 
     async connect(callback) {
@@ -24,17 +25,22 @@ class TdCache {
                     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();
+            this.redis_sub = redis.createClient(
+              {
+                  host: this.redis_host,
+                  port: this.redis_port,
+                  password: this.redis_password
+              });
+              // console.log("redis is:", this.redis_sub)
+            await this.redis_sub.connect();
         });
     }
 
@@ -43,202 +49,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 +109,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.2.133",
+  "version": "0.2.135",
   "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/DirectivesChatbotPlug.js

@@ -178,7 +178,7 @@ class DirectivesChatbotPlug {
   async nextDirective(directives) {
     if (this.log) {console.log("....nextDirective() checkStep():");}
     const go_on = await TiledeskChatbot.checkStep(
-      this.context.tdcache, this.context.requestId, this.chatbot.MAX_STEPS,  this.chatbot.MAX_EXECUTION_TIME, this.log
+      this.context.tdcache, this.context.requestId, this.chatbot?.MAX_STEPS,  this.chatbot?.MAX_EXECUTION_TIME, this.log
     );
     // const current_step = await TiledeskChatbot.currentStep(this.context.tdcache, this.context.requestId);
     // if (this.log) {console.log("........nextDirective() currentStep:", current_step);}

package/tiledeskChatbotPlugs/directives/DirMessage.js

@@ -93,6 +93,14 @@ class DirMessage {
     // const message = action.body.message;
     const message = action;
     if (this.log) {console.log("Message to extEndpoint:", JSON.stringify(message))};
+
+    if (this.projectId === "656054000410fa00132e5dcc") {
+      if (!message.text.startsWith('/')) {
+        callback();
+        return;
+      }
+    }
+
     let extEndpoint = `${this.API_ENDPOINT}/modules/tilebot`;
     if (this.TILEBOT_ENDPOINT) {
       extEndpoint = `${this.TILEBOT_ENDPOINT}`;