@tiledesk/tiledesk-tybot-connector 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -5,17 +5,8 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
-# v0.3.1
-- bug-fixed: callback is not defined
-
-# v0.2.153-rc8
-- added: fixToken function in TiledeskService utils class
-
-# v0.2.153-rc4
-- log added
-
-# v0.2.153-rc3
-- added: specchToText function to transcript audio file
+# v0.3.2
+- bug-fixed: minor improvement
 
 # v0.2.153-rc1
 - changed: context for gpt-40 and gpt-40-mini

package/TdCache copy.js

@@ -0,0 +1,242 @@
+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 {
+            await this.client.set(
+              key,
+              value,
+              'EX', options.EX);
+          }
+          catch(error) {
+            reject(error)
+          }
+        }
+        else {
+          try {
+            //console.log("setting here...key", key, value)
+            await this.client.set(
+              key,
+              value);
+          }
+          catch(error) {
+            console.error("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) => {
+        await this.client.del(key);
+        if (callback) {
+            callback();
+        }
+        return resolve();
+      })
+    }
+}
+
+module.exports = { TdCache };

package/index.js

@@ -65,17 +65,15 @@ router.post('/ext/:botid', async (req, res) => {
   }
 
  /** MANAGE AUDIO FILE MESSAGE */ 
-  let aiService = new AiService({
+ let aiService = new AiService({
     API_ENDPOINT: API_ENDPOINT,
     TOKEN: token,
     PROJECT_ID: projectId
   })
   let isAudio = TiledeskChatbotUtil.isAudioMessage(message)
   if(isAudio){
-    console.log('(chatbot index) is audio', message.metadata)
     let responseText = await aiService.speechToText(message.metadata.src).catch(err => {
-      console.log('errrr', err)
-      return res.status(400).send({"success": false, error: "Unable to translate audio message for request: " + requestId})
+      if(log) console.log('(index.js) aiService.speechToText error: ', err)
     })
     message.text= responseText.text
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {
@@ -15,7 +15,6 @@
     "@tiledesk/tiledesk-chatbot-client": "^0.5.30",
     "@tiledesk/tiledesk-chatbot-util": "^0.8.39",
     "@tiledesk/tiledesk-client": "^0.10.13",
-    "@tiledesk/tiledesk-multi-worker": "^0.1.14",
     "accept-language-parser": "^1.5.0",
     "axios": "^1.7.7",
     "body-parser": "^1.19.0",

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -3,7 +3,6 @@ const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
 const { TiledeskChatbotUtil } = require('../../models/TiledeskChatbotUtil');
 let axios = require('axios');
 const { TiledeskClient } = require('@tiledesk/tiledesk-client');
-const { Logger } = require('../../Logger');
 
 class DirReply {
 
@@ -17,7 +16,6 @@ class DirReply {
     this.token = context.token;
     this.tdcache = context.tdcache;
     this.log = context.log;
-    this.logger = new Logger({ request_id: this.requestId, dev: this.context.supportRequest.draft });
 
     this.API_ENDPOINT = context.API_ENDPOINT;
     this.tdClient = new TiledeskClient({
@@ -43,10 +41,7 @@ class DirReply {
       callback();
       return;
     }
-    this.logger.info("1 Execute action reply for " + directive.action.text)
-
     this.go(action, () => {
-      this.logger.info("6 End of action reply " + directive.action.text + " -> callback")
       callback();
     });
   }
@@ -69,8 +64,6 @@ class DirReply {
       const filler = new Filler();
       // fill text attribute
       message.text = filler.fill(message.text, requestAttributes);
-      this.logger.info("2 Sending reply " + message.text);
-
       if (message.metadata) {
         if (this.log) {console.log("filling message 'metadata':", JSON.stringify(message.metadata));}
         if (message.metadata.src) {
@@ -146,8 +139,6 @@ class DirReply {
     }
     // send!
     let cleanMessage = message;
-    this.logger.info("3 Sending reply (text) " + cleanMessage.text);
-    this.logger.info("4 Sending reply with clean message " + JSON.stringify(cleanMessage));
     // cleanMessage = TiledeskChatbotUtil.removeEmptyReplyCommands(message);
     // if (!TiledeskChatbotUtil.isValidReply(cleanMessage)) {
     //   console.log("invalid message", cleanMessage);
@@ -165,10 +156,8 @@ class DirReply {
       (err) => {
         if (err) {
           console.error("Error sending reply:", err);
-          this.logger.error("Error sending reply: " + err);
         }
         if (this.log) {console.log("Reply message sent:", JSON.stringify(cleanMessage));}
-        this.logger.info("5 Reply message sent");
         const delay = TiledeskChatbotUtil.totalMessageWait(cleanMessage);
         // console.log("got total delay:", delay)
         if (delay > 0 && delay <= 30000) { // prevent long delays

package/Logger.js

@@ -1,74 +0,0 @@
-let { Publisher } = require("@tiledesk/tiledesk-multi-worker");
-
-const AMQP_MANAGER_URL = process.env.AMQP_MANAGER_URL;
-let publisher = new Publisher(AMQP_MANAGER_URL, {
-    debug: false,
-    queueName: "logs_queue",
-    exchange: "tiledesk-multi",
-    topic: "logs",
-})
-
-class Logger {
-
-    constructor(config) {
-
-        if (!config) {
-            throw new Error('config is mandatory');
-        }
-
-        if (!config.request_id) {
-            console.error('config.request_id is mandatory');
-            //throw new Error('config.request_id is mandatory');
-        }
-
-        this.request_id = config.request_id;
-        this.dev = config.dev;
-
-        if (!AMQP_MANAGER_URL) {
-            console.error('AMQP_MANAGER_URL is undefined. Logger not available...');
-            return;
-            //throw new Error("Error starting logger: AMQP_MANAGER_URL is undefined.")
-        }
-
-    }
-
-    error(text) {
-        if (!this.request_id || !publisher) {
-            console.log("Return because request or publisher is undefined", this.request_id, publisher);
-            return;
-        }
-
-        let data = {
-            request_id: this.request_id,
-            text: text,
-            level: "error",
-            timestamp: new Date()
-        }
-        publisher.publish(data, (err, ok) => {
-            if (err) console.warn("publish log fail: ", err);
-            return;
-        })
-    }
-
-    info(text) {
-        if (!this.request_id || !publisher) {
-            console.log("Return because request or publisher is undefined", this.request_id, publisher);
-            return;
-        }
-
-        let data = {
-            request_id: this.request_id,
-            text: text,
-            level: "info",
-            timestamp: new Date()
-        }
-
-        publisher.publish(data, (err, ok) => {
-            if (err) console.warn("publish log fail: ", err);
-            return;
-        })
-    }
-
-}
-
-module.exports = { Logger }