@tiledesk/tiledesk-tybot-connector 0.4.2 → 0.5.0-rc2

package/tiledeskChatbotPlugs/directives/DirWebRequestV2.js

@@ -3,6 +3,7 @@ let https = require("https");
 const { Filler } = require('../Filler');
 const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
 const { DirIntent } = require('./DirIntent');
+const winston = require('../../utils/winston');
 
 class DirWebRequestV2 {
 
@@ -19,12 +20,13 @@ class DirWebRequestV2 {
   }
 
   execute(directive, callback) {
+    winston.verbose("Execute WebRequestV2 directive");
     let action;
     if (directive.action) {
       action = directive.action;
     }
     else {
-      console.error("Incorrect directive:", JSON.stringify(directive));
+      winston.warn("DirWebRequestV2 Incorrect directive: ", directive);
       callback();
       return;
     }
@@ -36,7 +38,8 @@ class DirWebRequestV2 {
   }
 
   async go(action, callback) {
-    if (this.log) { console.log("DirWebRequest action:", JSON.stringify(action)); }
+    winston.debug("(DirWebRequestV2) Action: ", action);
+
     if (!this.tdcache) {
       console.error("Error: DirWebRequest tdcache is mandatory");
       callback();
@@ -101,9 +104,6 @@ class DirWebRequestV2 {
     
     this.#myrequest(
       HTTPREQUEST, async (err, res) => {
-        if (this.log && err) {
-          console.log("webRequest error:", err);
-        }
         if (this.log) { console.log("DirWebRequest res:", res); }
         let resbody = res.data;
         let status = res.status;
@@ -238,7 +238,7 @@ class DirWebRequestV2 {
         });
       }
       else {
-        if (this.log) { console.log("No trueIntentDirective specified"); }
+        winston.debug("(DirWebRequestV2) No trueIntentDirective specified");
         if (callback) {
           callback();
         }
@@ -253,7 +253,7 @@ class DirWebRequestV2 {
         });
       }
       else {
-        if (this.log) { console.log("No falseIntentDirective specified"); }
+        winston.debug("(DirWebRequestV2) No falseIntentDirective specified");
         if (callback) {
           callback();
         }
@@ -262,53 +262,22 @@ class DirWebRequestV2 {
   }
 
   async #assignAttributes(action, resbody, status, error) {
-    if (this.log) {
-      console.log("assignAttributes resbody:", resbody)
-      console.log("assignAttributes error:", error)
-      console.log("assignAttributes status:", status)
-      console.log("assignAttributes action:", action)
-    }
+
     if (this.context.tdcache) {
       if (action.assignResultTo && resbody) {
-        if (this.log) { console.log("assign assignResultTo:", resbody); }
         await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignResultTo, resbody);
       }
       if (action.assignErrorTo && error) {
-        if (this.log) { console.log("assign assignResultTo:", error); }
         await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignErrorTo, error);
       }
       if (action.assignStatusTo && status) {
-        if (this.log) { console.log("assign assignStatusTo:", status); }
         await TiledeskChatbot.addParameterStatic(this.context.tdcache, this.context.requestId, action.assignStatusTo, status);
       }
-      // Debug log
-      if (this.log) {
-        const all_parameters = await TiledeskChatbot.allParametersStatic(this.context.tdcache, this.context.requestId);
-        for (const [key, value] of Object.entries(all_parameters)) {
-          if (this.log) { console.log("(webRequest) request parameter:", key, "value:", value, "type:", typeof value) }
-        }
-      }
     }
   }
 
   #myrequest(options, callback) {
     try {
-      if (this.log) {
-        console.log("API URL:", options.url);
-        //console.log("** Options:", JSON.stringify(options));
-        // Stringify "options". FIX THE STRINGIFY OF CIRCULAR STRUCTURE BUG - START
-        let cache = [];
-        let str_Options = JSON.stringify(options, function (key, value) { // try to use a separate function
-          if (typeof value === 'object' && value != null) {
-            if (cache.indexOf(value) !== -1) {
-              return;
-            }
-            cache.push(value);
-          }
-          return value;
-        });
-        console.log("** Options:", str_Options);
-      }
       let axios_options = {
         url: options.url,
         method: options.method,
@@ -322,9 +291,6 @@ class DirWebRequestV2 {
       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,
@@ -334,35 +300,11 @@ class DirWebRequestV2 {
 
       axios(axios_options)
         .then((res) => {
-          if (this.log) {
-            console.log("Success Response:", res);
-            console.log("Response for url:", options.url);
-            console.log("Response headers:\n", JSON.stringify(res.headers));
-          }
           if (callback) {
             callback(null, res);
           }
         })
         .catch((err) => {
-          if (this.log) {
-            if (err.response) {
-              console.log("Error Response data:", err.response.data);
-            }
-            // FIX THE STRINGIFY OF CIRCULAR STRUCTURE BUG - START
-            let cache = [];
-            let error_log = JSON.stringify(err, function (key, value) { // try to use a separate function
-              if (typeof value === 'object' && value != null) {
-                if (cache.indexOf(value) !== -1) {
-                  return;
-                }
-                cache.push(value);
-              }
-              return value;
-            });
-            console.error("(DirWebRequestv2) An error occurred: ", error_log);
-            // FIX THE STRINGIFY OF CIRCULAR STRUCTURE BUG - END
-            // console.error("An error occurred:", JSON.stringify(err));
-          }
           if (callback) {
             let status = 1000;
             let cache = [];
@@ -398,7 +340,7 @@ class DirWebRequestV2 {
         });
     }
     catch (error) {
-      console.error("Error:", error);
+      winston.error("Error: ", error);
     }
   }
 
@@ -407,20 +349,13 @@ class DirWebRequestV2 {
     if (!action.settings) {
       return timeout;
     }
-    // console.log("default timeout:", timeout);
-    // console.log("action.settings:", action.settings);
-    // console.log("action.settings.timeout:", action.settings.timeout);
-    // console.log("typeof action.settings.timeout:", typeof action.settings.timeout);
-    // console.log("action.settings.timeout > min", action.settings.timeout > min)
-    // console.log("action.settings.timeout < max", action.settings.timeout < max)  
-
+   
+    
     if (action.settings.timeout) {
       if ((typeof action.settings.timeout === "number") && action.settings.timeout > min && action.settings.timeout < max) {
         timeout = Math.round(action.settings.timeout)
-        // console.log("new timeout:", timeout);
       }
     }
-    // console.log("returning timeout:", timeout);
     return timeout
   }
 

package/tiledeskChatbotPlugs/directives/DirWebResponse.js

@@ -34,10 +34,10 @@ class DirWebResponse {
   }
 
   async go(action, callback) {
-    console.log("Web response...");
-    let payload = action.payload;
-    let status = action.status;
-
+    if (this.log) {
+      console.log("(DirWebResponse) action:", action);
+    }
+    
     let requestAttributes = null;
     if (this.tdcache) {
       requestAttributes = 
@@ -45,7 +45,7 @@ class DirWebResponse {
       const filler = new Filler();
 
       try {
-        payload = filler.fill(payload, requestAttributes);
+        let status = action.status;
         status = filler.fill(status, requestAttributes);
       }
       catch(e) {
@@ -54,16 +54,19 @@ class DirWebResponse {
       
     }
 
+    const json = await this.getJsonFromAction(action, filler, requestAttributes)
     let webResponse = {
       status: status,
-      payload: payload
+      payload: json
     }
 
     const topic = `/webhooks/${this.requestId}`;
     
     try {
       this.tdcache.publish(topic, JSON.stringify(webResponse));
-      console.log("Published webresponse to topic:", topic);
+      if (this.log) {
+        console.log("(DirWebResponse) Published webresponse to topic:", topic);
+      }
     }
     catch(e) {
       console.error(e)
@@ -72,8 +75,32 @@ class DirWebResponse {
     callback();
     
   }
+
+  async getJsonFromAction(action, filler, requestAttributes) {
+  
+      return new Promise( async (resolve, reject) => {
+  
+        if (action.payload && action.bodyType == "json") {
+          let jsonBody = filler.fill(action.payload, requestAttributes);
+          try {
+            let json = JSON.parse(jsonBody);
+            resolve(json);
+          }
+          catch (err) {
+            if (this.log) { console.error("Error parsing webRequest jsonBody:", jsonBody, err) };
+            reject("Error parsing jsonBody");
+          }
+        }
+        else {
+          resolve(null);
+        }
+      })
+  }
+
 }
 
+
+
 /**
  * A stub to send message to the "ext/botId" endpoint, hosted by tilebot on:
  * /${TILEBOT_ROUTE}/ext/${botId}

package/tiledeskChatbotPlugs/directives/DirWhatsappByAttribute.js

@@ -1,5 +1,6 @@
 const axios = require("axios").default;
 const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
+const winston = require('../../utils/winston');
 
 let whatsapp_api_url;
 
@@ -15,13 +16,13 @@ class DirWhatsappByAttribute {
   }
 
   execute(directive, callback) {
-    console.log("\n\nwhatsapp by attribtues action (execute) - directive: ", directive);
+    winston.verbose("Execute WhatsappByAttribute directive");
     let action;
     if (directive.action) {
       action = directive.action;
     }
     else {
-      console.error("Incorrect directive: ", JSON.stringify(directive));
+      winston.warn("DirWhatsappByAttribute Incorrect directive: ", directive);
       callback();
       return;
     }
@@ -31,10 +32,7 @@ class DirWhatsappByAttribute {
   }
 
   async go(action, callback) {
-
-    if (this.log) {
-      console.log("whatsapp by attributes action: ", JSON.stringify(action))
-    }
+    winston.debug("(DirWhatsappByAttribute) Action: ", action);
 
     const whatsapp_api_url_pre = process.env.WHATSAPP_ENDPOINT;
 
@@ -43,20 +41,20 @@ class DirWhatsappByAttribute {
     } else {
       whatsapp_api_url = this.API_ENDPOINT + "/modules/whatsapp/api"
     }
-    console.log("DirWhatsappByAttribute whatsapp_api_url: ", whatsapp_api_url);
+    winston.debug("(DirWhatsappByAttribute) whatsapp_api_url: " + whatsapp_api_url);
 
     if (!action.attributeName) {
-      console.error("DirWhatsappByAttribute attributeName is mandatory")
+      winston.error("(DirWhatsappByAttribute) attributeName is mandatory")
       callback();
       return;
     }
-    if (this.log) { console.log("DirWhatsappByAttribute attributeName: ", action.attributeName )};
+    winston.debug("(DirWhatsappByAttribute) attributeName: " + action.attributeName )
 
     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)); }
+    winston.debug("(DirWhatsappByAttribute) attribute_value:", attribute_value);
 
     if (attribute_value == null) {
-      console.error("DirWhatsappByAttribute attribute_value is undefined");
+      winston.error("(DirWhatsappByAttribute)  attribute_value is undefined");
       callback();
       return;
     }
@@ -86,7 +84,7 @@ class DirWhatsappByAttribute {
             if (callback) {
               callback(null, resbody);
             }
-            console.log("(tybot) broadcast sent: ", resbody);
+            winston.debug("(DirWhatsappByAttribute) broadcast sent: ", resbody);
             resolve(resbody);
           }
         }, true);
@@ -96,7 +94,6 @@ class DirWhatsappByAttribute {
 
   // HTTP REQUEST
   static async myrequest(options, callback, log) {
-    console.log("my request execution")
     return await axios({
       url: options.url,
       method: options.method,
@@ -115,7 +112,7 @@ class DirWhatsappByAttribute {
         }
       }
     }).catch((err) => {
-      console.error("(tybot request) An error occured: ", err);
+      winston.error("(DirWhatsappByAttribute) An error occured: ", err);
       if (callback) {
         callback(err, null, null);
       }

package/tiledeskChatbotPlugs/directives/Directives.js

@@ -58,6 +58,7 @@ class Directives {
   static MOVE_TO_UNASSIGNED = "move_to_unassigned";
   static CONNECT_BLOCK = "connect_block";
   static ADD_TAGS = 'add_tags'
+  static WEBHOOK = 'webhook';
   static WEB_RESPONSE = "web_response";
 
   // static WHEN_ONLINE_MOVE_TO_AGENT = "whenonlinemovetoagent"; // DEPRECATED?
@@ -74,13 +75,10 @@ class Directives {
   // static CONDITION = "condition"; // DEPRECATED
 
   static actionToDirective(action) {
-    // console.log("actionToDirective:", action);
     let directive = {
       name: action["_tdActionType"],
       action: action
     }
-    // delete directive.action["_tdActionType"];
-    // console.log("Directive out:", directive);
     return directive;
   }
 }

package/utils/winston.js

@@ -0,0 +1,42 @@
+require('dotenv').config();
+var appRoot = require('app-root-path');
+var winston = require('winston');
+var level = process.env.LOG_LEVEL || "info";
+
+var options = {
+  file: {
+    level:level ,
+    filename: `${appRoot}/logs/app.log`,
+    handleExceptions: true,
+    json: false,
+    maxsize: 5242880, // 5MB
+    maxFiles: 5,
+    colorize: false,
+    format: winston.format.simple()
+  },
+  console: {
+    level: level,
+    handleExceptions: true,
+    json: true,
+    colorize: true,
+    // timestamp: true,
+    format: winston.format.simple()     
+  },
+};
+
+let logger = winston.createLogger({    
+  transports: [
+   new (winston.transports.Console)(options.console),
+   new (winston.transports.File)(options.file),
+  ],
+  exitOnError: false, // do not exit on handled exceptions
+});
+
+logger.stream = {
+  write: function(message, encoding) {
+    logger.info(message);
+  },
+};
+
+
+module.exports = logger;

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 };