@tiledesk/tiledesk-tybot-connector 2.0.8-rc2 → 2.0.8

package/tiledeskChatbotPlugs/directives/DirReply.js

@@ -17,7 +17,7 @@ class DirReply {
     this.requestId = context.requestId;
     this.token = context.token;
     this.tdcache = context.tdcache;
-    this.supportRequest = this.context.supportRequest;
+    this.log = context.log;
     this.logger = new Logger({ request_id: this.requestId, dev: this.context.supportRequest.draft });
 
     this.API_ENDPOINT = context.API_ENDPOINT;
@@ -25,7 +25,8 @@ class DirReply {
       projectId: this.context.projectId,
       token: this.context.token,
       APIURL: this.API_ENDPOINT,
-      APIKEY: "___"
+      APIKEY: "___",
+      log: this.log
     });
   }
 
@@ -43,10 +44,10 @@ class DirReply {
       callback();
       return;
     }
-    this.logger.info("Executing Action Reply ", directive.action)
+    this.logger.info("1 Execute action reply for " + directive.action.text)
 
     this.go(action, () => {
-      this.logger.info("Action Reply terminated")
+      this.logger.info("6 End of action reply " + directive.action.text + " -> callback")
       callback();
     });
   }
@@ -67,16 +68,15 @@ 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) {
         winston.debug("DirReply filling message 'metadata':", message.metadata);
         if (message.metadata.src) {
           message.metadata.src = filler.fill(message.metadata.src, requestAttributes);
-          this.logger.debug("Filled metadata.src with ", message.metadata.src);
         }
         if (message.metadata.name) {
           message.metadata.name = filler.fill(message.metadata.name, requestAttributes);
-          this.logger.debug("Filled metadata.name with ", message.metadata.name);
         }
       }
       winston.debug("DirReply filling commands'. Message:", message);
@@ -89,7 +89,7 @@ class DirReply {
             let command = commands[i];
             if (command.type === 'message' && command.message && command.message.text) {
               command.message.text = filler.fill(command.message.text, requestAttributes);
-              TiledeskChatbotUtil.fillCommandAttachments(command, requestAttributes);
+              TiledeskChatbotUtil.fillCommandAttachments(command, requestAttributes, this.log);
               winston.debug("DirReply command filled: " + command.message.text);
             }
             if (command.type === 'settings' && command.settings) {
@@ -143,6 +143,15 @@ class DirReply {
     }
 
     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);
+    //   callback(); // cancel reply operation
+    //   return;
+    // }
+    
     cleanMessage.senderFullname = this.context.chatbot.bot.name;
     winston.debug("DirReply reply with clean message: ", cleanMessage);
 
@@ -153,8 +162,10 @@ class DirReply {
       (err) => {
         if (err) {
           winston.error("DirReply Error sending reply: ", err);
+          this.logger.error("Error sending reply: " + err);
         }
         winston.verbose("DirReply reply message sent")
+        this.logger.info("5 Reply message sent");
         const delay = TiledeskChatbotUtil.totalMessageWait(cleanMessage);
         if (delay > 0 && delay <= 30000) { // prevent long delays
           setTimeout(() => {

package/tiledeskChatbotPlugs/directives/DirReplyV2.js

@@ -20,6 +20,7 @@ class DirReplyV2 {
     this.requestId = context.requestId;
     this.token = context.token;
     this.tdcache = context.tdcache;
+    this.log = context.log;
     this.intentDir = new DirIntent(context);
     this.chatbot = context.chatbot;
     this.reply = context.reply;
@@ -30,7 +31,8 @@ class DirReplyV2 {
       projectId: this.context.projectId,
       token: this.context.token,
       APIURL: this.API_ENDPOINT,
-      APIKEY: "___"
+      APIKEY: "___",
+      log: this.log
     });
   }
 
@@ -59,10 +61,11 @@ class DirReplyV2 {
     const message = action;
 
     let current; // debug only
-    if (message.attributes.commands[1].message.text) {
-      current = message.attributes.commands[1].message.text
+    if (this.log) {
+      if (message.attributes.commands[1].message.text) {
+        current = message.attributes.commands[1].message.text
+      }
     }
-    
     let must_stop = false;
     // fill
     let requestAttributes = null;
@@ -71,9 +74,11 @@ class DirReplyV2 {
       await TiledeskChatbot.allParametersStatic(
         this.tdcache, this.requestId
       );
-      // for (const [key, value] of Object.entries(requestAttributes)) {
-      //   const value_type = typeof value;
-      // }
+      if (this.log) {
+        for (const [key, value] of Object.entries(requestAttributes)) {
+          const value_type = typeof value;
+        }
+      }
 
       TiledeskChatbotUtil.replaceJSONButtons(message, requestAttributes);
 
@@ -192,7 +197,7 @@ class DirReplyV2 {
             let command = commands[i];
             if (command.type === 'message' && command.message && command.message.text) {
               command.message.text = filler.fill(command.message.text, requestAttributes);
-              TiledeskChatbotUtil.fillCommandAttachments(command, requestAttributes);
+              TiledeskChatbotUtil.fillCommandAttachments(command, requestAttributes, this.log);
             }
           }
         }

package/tiledeskChatbotPlugs/directives/DirSendEmail.js

@@ -15,13 +15,15 @@ class DirSendEmail {
     this.context = context;
     this.tdcache = context.tdcache;
     this.requestId = context.requestId;
+    this.log = context.log;    
 
     this.API_ENDPOINT = context.API_ENDPOINT;
     this.tdClient = new TiledeskClient({
       projectId: this.context.projectId,
       token: this.context.token,
       APIURL: this.API_ENDPOINT,
-      APIKEY: "___"
+      APIKEY: "___",
+      log: this.log
     });
   }
 

package/tiledeskChatbotPlugs/directives/DirSendWhatsapp.js

@@ -19,6 +19,7 @@ class DirSendWhatsapp {
     this.requestId = this.context.requestId;
     this.intentDir = new DirIntent(context);
     this.API_ENDPOINT = this.context.API_ENDPOINT;
+    this.log = context.log;
   }
 
   execute(directive, callback) {

package/tiledeskChatbotPlugs/directives/DirSetAttribute.js

@@ -77,6 +77,7 @@ class DirSetAttribute {
             throw new Error('context object is mandatory.');
         }
         this.context = context;
+        this.log = context.log;
     }
 
     execute(directive, callback) {

package/tiledeskChatbotPlugs/directives/DirSetAttributeV2.js

@@ -79,6 +79,7 @@ class DirSetAttributeV2 {
         }
         this.context = context;
         this.tdcache = context.tdcache;
+        this.log = context.log;
     }
 
     execute(directive, callback) {
@@ -198,7 +199,9 @@ class DirSetAttributeV2 {
         httpUtils.request(
             HTTPREQUEST, async (err, resbody) => {
                 if (err) {
-                    winston.error("(DirSetAttributeV2) persistOnTiledesk() error: ", err);
+                    if (this.log) {
+                        winston.error("(DirSetAttributeV2) persistOnTiledesk() error: ", err);
+                    }
                 } else {
                     winston.debug("(DirSetAttributeV2) Attributes saved: ", resbody);
                 }

package/tiledeskChatbotPlugs/directives/DirSetConversationTags.js

@@ -9,6 +9,7 @@ class DirSetConversationTags {
       throw new Error('context object is mandatory.');
     }
     this.context = context;
+    this.log = context.log;
     this.requestId = context.requestId;
 
     this.API_ENDPOINT = context.API_ENDPOINT;
@@ -16,7 +17,8 @@ class DirSetConversationTags {
       projectId: this.context.projectId,
       token: this.context.token,
       APIURL: this.API_ENDPOINT,
-      APIKEY: "___"
+      APIKEY: "___",
+      log: this.log
     });
   }
 

package/tiledeskChatbotPlugs/directives/DirUnlockIntent.js

@@ -11,6 +11,7 @@ class DirUnlockIntent {
       throw new Error('tdcache (TdCache) object is mandatory.');
     }
     this.tdcache = context.tdcache;
+    this.log = context.log;
   }
 
   async execute(directive, callback) {

package/tiledeskChatbotPlugs/directives/DirWait.js

@@ -12,6 +12,7 @@ class DirWait {
     this.chatbot = context.chatbot;
     this.tdcache = context.tdcache;
     this.requestId = context.requestId;
+    this.log = context.log;
   }
 
   execute(directive, callback) {

package/tiledeskChatbotPlugs/directives/DirWebRequest.js

@@ -13,6 +13,7 @@ class DirWebRequest {
     this.context = context;
     this.tdcache = context.tdcache;
     this.requestId = context.requestId;
+    this.log = context.log;
   }
 
   execute(directive, callback) {

package/tiledeskChatbotPlugs/directives/DirWebRequestV2.js

@@ -16,6 +16,7 @@ class DirWebRequestV2 {
     this.requestId = context.requestId;
     this.chatbot = context.chatbot;
     this.intentDir = new DirIntent(context);
+    this.log = context.log;
   }
 
   execute(directive, callback) {
@@ -301,7 +302,21 @@ class DirWebRequestV2 {
           }
         })
         .catch((err) => {
-          // FIX THE STRINGIFY OF CIRCULAR STRUCTURE BUG - END
+          if (this.log) {
+            // 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;
+            });
+            winston.error("(DirWebRequestv2) An error occurred: ", error_log);
+            // FIX THE STRINGIFY OF CIRCULAR STRUCTURE BUG - END
+          }
           if (callback) {
             let status = 1000;
             let cache = [];

package/tiledeskChatbotPlugs/directives/DirWebRequestV2_old.js

@@ -0,0 +1,417 @@
+let axios = require('axios');
+let https = require("https");
+const { Filler } = require('../Filler');
+const { TiledeskChatbot } = require('../../engine/TiledeskChatbot');
+const { DirIntent } = require('./DirIntent');
+
+class DirWebRequestV2 {
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory.');
+    }
+    this.context = context;
+    this.tdcache = context.tdcache;
+    this.requestId = context.requestId;
+    this.chatbot = context.chatbot;
+    this.intentDir = new DirIntent(context);
+    this.log = context.log;
+  }
+
+  execute(directive, callback) {
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("Incorrect directive:", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, (stop) => {
+      if (this.log) {console.log("(webrequestv2, stop?", stop); }
+      callback(stop);
+    });
+  }
+
+  async go(action, callback) {
+    if (this.log) {console.log("webRequest action:", JSON.stringify(action));}
+
+    // Condition branches
+    let trueIntent = action.trueIntent;
+    let falseIntent = action.falseIntent;
+    const trueIntentAttributes = action.trueIntentAttributes;
+    const falseIntentAttributes = action.falseIntentAttributes;
+    let stopOnConditionMet = action.stopOnConditionMet;
+    if (trueIntent && trueIntent.trim() === "") {
+      trueIntent = null;
+    }
+    if (falseIntent && falseIntent.trim() === "") {
+      falseIntent = null;
+    }
+
+    let requestAttributes = null;
+    if (this.tdcache) {
+      requestAttributes = 
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      );
+    }
+    const filler = new Filler();
+    const url = filler.fill(action.url, requestAttributes);
+
+    let headers = {};
+    if (action.headersString) {
+      let headersDict = action.headersString
+      for (const [key, value] of Object.entries(headersDict)) {
+        if (this.log) {console.log("header:", key, "value:", value)}
+        let filled_value = filler.fill(value, requestAttributes);
+        headers[key] = filled_value;
+      }
+    }
+
+    let json = null;
+    try {
+      if (action.jsonBody && action.bodyType == "json") {
+        if (this.log) {console.log("action.body is:", action.jsonBody);}
+        let jsonBody = filler.fill(action.jsonBody, requestAttributes);
+        try {
+          json = JSON.parse(jsonBody);
+          if (this.log) {console.log("json is:", json);}
+        }
+        catch(err) {
+          console.error("Error parsing webRequest jsonBody:", jsonBody);
+          if (callback) {
+            if (falseIntent) {
+              await this.chatbot.addParameter("flowError", "Error parsing jsonBody");
+              this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, () => {
+                console.log('herrrrr 11111' )
+                callback(true); // stop the flow
+                return;
+              });
+            }
+            else {
+              console.log('herrrrr 2222' )
+              callback(false); // continue the flow
+              return;
+            }
+          }
+        }
+      }
+      else if (action.formData && action.bodyType == "form-data") {
+        let formData = filler.fill(action.formData, requestAttributes);
+        if (this.log) {console.log("action.body is form-data:", formData);}
+        // // fill
+        if (formData && formData.length > 0) {
+          for (let i = 0; i < formData.length; i++) {
+            let field = formData[i];
+            if (field.value) {
+              field.value = filler.fill(field.value, requestAttributes);
+              if (this.log) {console.log("field filled:", field.value);}
+            }
+          }
+        }
+        json = {};
+        for (let i = 0; i < formData.length; i++) {
+          let field = formData[i];
+          if (field.enabled && field.value && field.type === "URL") {
+            if (this.log) {console.log("Getting file:", field.value);}
+            let response = await axios.get(field.value,
+              {
+                responseType: 'stream'
+              }
+            );
+            let stream = response.data;
+            // if (this.log) {console.log("Stream data:", stream);}
+            json[field.name] = stream;
+            // process.exit(0);
+          }
+          else if (field.enabled && field.value && field.type === "Text") {
+            json[field.name] = field.value;
+          }
+        }
+        if (this.log) {console.log("final json:", json);}
+      }
+      else {
+        if (this.log) {console.log("no action upload parts");}
+      }
+
+    }
+    catch(error) {
+      console.error("Error", error);
+      if (callback) {
+        if (falseIntent) {
+          await this.chatbot.addParameter("flowError", "Error: " + error);
+          this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, () => {
+            callback(true); // stop the flow
+            return;
+          });
+        }
+        else {
+          callback(false); // continue the flow
+          return;
+        }
+      }
+    }
+    
+    
+
+    let timeout = this.#webrequest_timeout(action, 20000, 1, 300000);
+    
+    if (this.log) {console.log("webRequest URL", url);}
+    
+    const HTTPREQUEST = {
+      url: url,
+      headers: headers,
+      json: json,
+      method: action.method,
+      timeout: timeout
+    };
+
+    if (this.log) {console.log("webRequest HTTPREQUEST", HTTPREQUEST);}
+    this.#myrequest(
+      HTTPREQUEST, async (err, res) => {
+        if (this.log && err) {
+          console.log("webRequest error:", err);
+        }
+        if (this.log) {console.log("got res:", res);}
+        let resbody = res.data;
+        let status = res.status;
+        let error = res.error;
+        await this.#assignAttributes(action, resbody, status, error)
+        if (this.log) {console.log("webRequest resbody:", resbody);}
+        if (err) {
+          if (this.log) {console.error("webRequest error:", err);}
+          if (callback) {
+            if (falseIntent) {
+              this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, () => {
+                callback(true); // stop the flow
+              });
+            }
+            else {
+              callback(false); // continue the flow
+            }
+          }
+        }
+        else if(res.status >= 200 && res.status <= 299) {
+          if (trueIntent) {
+            await this.#executeCondition(true, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, () => {
+              callback(true); // stop the flow
+            });
+          }
+          else {
+            callback(false); // continue the flow
+          }
+        }
+        else {
+          if (falseIntent) {
+            this.#executeCondition(false, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, () => {
+              callback(true); // stop the flow
+            });
+          }
+          else {
+            callback(false); // continue the flow
+          }
+        }
+      }
+    );
+  }
+
+  async #executeCondition(result, trueIntent, trueIntentAttributes, falseIntent, falseIntentAttributes, callback) {
+    let trueIntentDirective = null;
+    if (trueIntent) {
+      trueIntentDirective = DirIntent.intentDirectiveFor(trueIntent, trueIntentAttributes);
+    }
+    let falseIntentDirective = null;
+    if (falseIntent) {
+      falseIntentDirective = DirIntent.intentDirectiveFor(falseIntent, falseIntentAttributes);
+    }
+    if (result === true) {
+      if (trueIntentDirective) {
+        this.intentDir.execute(trueIntentDirective, () => {
+          callback();
+        });
+      }
+      else {
+        if (this.log) {console.log("No trueIntentDirective specified");}
+        callback();
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.intentDir.execute(falseIntentDirective, () => {
+          callback();
+        });
+      }
+      else {
+        if (this.log) {console.log("No falseIntentDirective specified");}
+        callback();
+      }
+    }
+  }
+
+  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,
+        params: options.params,
+        headers: options.headers,
+        timeout: options.timeout,
+        maxContentLength: 10000000, // max 10mb response size
+        maxBodyLength: 10000000 // max 10mb request body size
+      }
+    
+      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("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("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 = [];
+          let str_error = 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;
+          });
+          let error = JSON.parse(str_error) // "status" disappears without this trick
+          let errorMessage = JSON.stringify(error);
+          if (error.status) {
+            status = error.status;
+          }
+          if (error.message) {
+            errorMessage = error.message;
+          }
+          let data = null;
+          if (err.response) {
+            data =  err.response.data;
+          }
+          callback(
+            null, {
+              status: status,
+              data: data,
+              error: errorMessage
+            }
+          );
+        }
+      });
+    }
+    catch(error) {
+      console.error("Error:", error);
+    }
+  }
+
+  #webrequest_timeout(action, default_timeout, min, max) {
+    let timeout = default_timeout;
+    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
+  }
+
+}
+
+module.exports = { DirWebRequestV2 };