@tiledesk/tiledesk-tybot-connector 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -5,9 +5,18 @@
 available on:
  ▶️ https://www.npmjs.com/package/@tiledesk/tiledesk-tybot-connector
 
-# v0.3.0
+# 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.2.153-rc1
 - changed: context for gpt-40 and gpt-40-mini
 

package/ExtApi.js

@@ -76,7 +76,6 @@ class ExtApi {
    * @param {string} token. User token
    */
   // sendMessageToBot(message, botId, token, callback) {
-  //   const jwt_token = this.fixToken(token);
   //   const url = `${this.ENDPOINT}/ext/${botId}`;
   //   if (this.log) {console.log("sendMessageToBot URL", url);}
   //   const HTTPREQUEST = {

package/Logger.js

@@ -0,0 +1,74 @@
+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 }

package/TiledeskServices/AIService.js

@@ -0,0 +1,43 @@
+const Utils = require('./utils')
+class AiService {
+
+    constructor(options){
+        this.APIURL = options.API_ENDPOINT
+        this.TOKEN = options.TOKEN
+        this.PROJECT_ID = options.PROJECT_ID
+    }
+
+    async speechToText(url){
+        return new Promise((resolve, reject)=> {
+          const HTTPREQUEST = {
+              url: `${this.APIURL}/${this.PROJECT_ID}/llm/transcription`,
+              headers: {
+                'Content-Type' : 'application/json',
+                'Authorization': Utils.fixToken(this.TOKEN)
+              },
+              json: {
+                url: url
+              },
+              method: 'POST',
+              httpsOptions: this.httpsOptions
+          };
+          Utils.myrequest(
+            HTTPREQUEST,
+            function(err, resbody) {
+                if (err) {
+                  reject(err)
+                }
+                else {
+                  resolve(resbody)
+                }
+            }, this.LOG
+          );
+        }); 
+      }
+
+
+
+
+}
+
+module.exports= AiService

package/TiledeskServices/utils.js

@@ -0,0 +1,99 @@
+let axios = require('axios');
+let https = require("https");
+
+class Utils {
+    constructor(){}
+
+
+    static myrequest(options, callback, log) {
+        if (log) {
+          console.log("** API URL:", options.url);
+          console.log("** Options:", JSON.stringify(options));
+        }
+        let axios_settings = {
+          url: options.url,
+          method: options.method,
+          data: options.json,
+          params: options.params,
+          headers: options.headers
+        }
+        // console.log("options.url.startsWith(https:)", options.url.startsWith("https:"))
+        // console.log("this.httpsOptions", this.httpsOptions)
+        
+        if (options.url.startsWith("https:") && options.httpsOptions) {
+          // console.log("Tiledesk Client v 0.9.x: url.startsWith https: && httpsOptions");
+          const httpsAgent = new https.Agent(options.httpsOptions);
+          axios_settings.httpsAgent = httpsAgent;
+        }
+        else if (options.url.startsWith("https:") && !options.httpsOptions) {
+          // HTTPS default is rejectUnauthorized: false
+          // console.log("Tiledesk Client v 0.9.x: url.startsWith https: && NOT httpsOptions");
+          const httpsAgent = new https.Agent({
+            rejectUnauthorized: false,
+          });
+          axios_settings.httpsAgent = httpsAgent;
+        }
+
+
+        
+        // console.log("Using axios settings:", axios_settings)
+        // axios(
+        //   {
+        //     url: options.url,
+        //     method: options.method,
+        //     data: options.json,
+        //     params: options.params,
+        //     httpsAgent: httpsAgent,
+        //     headers: options.headers
+        //   })
+        axios(axios_settings)
+        .then(function (res) {
+          if (log) {
+            console.log("Response for url:", options.url);
+            console.log("Response headers:\n", JSON.stringify(res.headers));
+            // console.log("******** Response for url:", res);
+          }
+          
+          if (res && res.status == 200 && res.data) {
+            if (callback) {
+              callback(null, res.data);
+            }
+          }
+          else {
+            
+            if (callback) {
+              callback(Utils.getErr({message: "Response status not 200"}, options, res), null, null);
+            }
+          }
+        })
+        .catch(function (error) {
+          // console.error(error); 
+          if (callback) {
+            callback(error, null, null);
+          }
+        });
+    }
+
+    static getErr(err, request, response) {
+        let res_err = {}
+        res_err.http_err = err;
+        res_err.http_request = request;
+        res_err.http_response = response;
+        return res_err;
+    }
+
+    static fixToken(token) {
+        if (token.startsWith('JWT ')) {
+            return token;
+        }
+        else {
+            return 'JWT ' + token;
+        }
+    }
+
+
+
+
+}
+
+module.exports = Utils

package/index.js

@@ -32,6 +32,7 @@ const { DirectivesChatbotPlug } = require('./tiledeskChatbotPlugs/DirectivesChat
 let mongoose = require('mongoose');
 // const { Directives } = require('./tiledeskChatbotPlugs/directives/Directives.js');
 const { TiledeskChatbotUtil } = require('./models/TiledeskChatbotUtil.js'); //require('@tiledesk/tiledesk-chatbot-util');
+const AiService = require('./TiledeskServices/AIService.js');
 let API_ENDPOINT = null;
 let TILEBOT_ENDPOINT = null;
 let staticBots;
@@ -63,13 +64,21 @@ router.post('/ext/:botid', async (req, res) => {
     message.request.id_project = projectId;
   }
 
-  // let request_check = checkRequest(message.request.request_id, message.id_project);
-  // if (request_check === true) {
-  //   res.status(200).send({ "successs": true });
-  // } else {
-  //   return res.status(400).send({ "success": false, "message": "Invalid request_id"})
-  // }
-  // res.status(200).send({"success":true});
+ /** MANAGE AUDIO FILE MESSAGE */ 
+  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})
+    })
+    message.text= responseText.text
+  }
 
   // validate reuqestId
   let isValid = TiledeskChatbotUtil.validateRequestId(requestId, projectId);
@@ -760,7 +769,6 @@ async function checkRequest(request_id, id_project) {
  * @param {string} token. User token
  */
 function sendMessageToBot(TILEBOT_ENDPOINT, message, botId, callback) {
-  // const jwt_token = this.fixToken(token);
   const url = `${TILEBOT_ENDPOINT}/ext/${botId}`;
   console.log("sendMessageToBot URL", url);
   const HTTPREQUEST = {

package/models/TiledeskChatbotUtil.js

@@ -480,6 +480,13 @@ class TiledeskChatbotUtil {
         return false;
     }
 
+    static isAudioMessage(message){
+        if (message && message.type && message.type === 'file' && message.metadata && message.metadata.src && message.metadata.type.includes('audio') ) {
+            return true;
+        }
+        return false;
+    }
+
     static lastUserMessageFrom(msg) {
         let message = {};
         message["senderFullname"] = msg["senderFullname"]; // ex. "Bot"
@@ -926,7 +933,6 @@ class TiledeskChatbotUtil {
      * @param {string} requestId. Tiledesk chatbot/requestId parameters
      */
     getChatbotParameters(requestId, callback) {
-        // const jwt_token = this.fixToken(token);
         const url = `${process.env.TILEBOT_ENDPOINT}/ext/reserved/parameters/requests/${requestId}?all`;
         const HTTPREQUEST = {
             url: url,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-tybot-connector",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Tiledesk Tybot connector",
   "main": "index.js",
   "scripts": {
@@ -15,6 +15,7 @@
     "@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/DirConnectBlock.js

@@ -108,7 +108,6 @@ class DirConnectBlock {
    * @param {string} token. User token
    */
   sendMessageToBot(TILEBOT_ENDPOINT, message, botId, callback) {
-    // const jwt_token = this.fixToken(token);
     const url = `${TILEBOT_ENDPOINT}/ext/${botId}`;
     // console.log("sendMessageToBot URL", url);
     const HTTPREQUEST = {

package/tiledeskChatbotPlugs/directives/DirIntent.js

@@ -133,7 +133,6 @@ class DirIntent {
    * @param {string} token. User token
    */
   sendMessageToBot(TILEBOT_ENDPOINT, message, botId, callback) {
-    // const jwt_token = this.fixToken(token);
     const url = `${TILEBOT_ENDPOINT}/ext/${botId}`;
     // console.log("sendMessageToBot URL", url);
     const HTTPREQUEST = {

package/tiledeskChatbotPlugs/directives/DirMessageToBot.js

@@ -61,7 +61,6 @@ class DirMessageToBot {
    * @param {string} token. User token
    */
   sendMessageToBot(TILEBOT_ENDPOINT, message, botId, callback) {
-    // const jwt_token = this.fixToken(token);
     const url = `${TILEBOT_ENDPOINT}/ext/${botId}`;
     // console.log("sendMessageToBot URL", url);
     const HTTPREQUEST = {

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -3,6 +3,7 @@ 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 {
 
@@ -16,6 +17,7 @@ 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({
@@ -41,7 +43,10 @@ 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();
     });
   }
@@ -64,6 +69,8 @@ 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) {
@@ -139,6 +146,8 @@ 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);
@@ -156,8 +165,10 @@ 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/TdCache copy.js

@@ -1,242 +0,0 @@
-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 };