@tiledesk/tiledesk-tybot-connector 0.2.601-rc1 → 0.3.1

package/tiledeskChatbotPlugs/directives/DirReplyV2.js

@@ -0,0 +1,347 @@
+const { Filler } = require('../Filler');
+const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
+const { TiledeskChatbotConst } = require('../../models/TiledeskChatbotConst');
+const { TiledeskChatbotUtil } = require('../../models/TiledeskChatbotUtil');
+const { DirIntent } = require("./DirIntent");
+// const { defaultOptions } = require('liquidjs');
+const { DirMessageToBot } = require('./DirMessageToBot');
+const { v4: uuidv4 } = require('uuid');
+const { TiledeskClient } = require('@tiledesk/tiledesk-client');
+
+class DirReplyV2 {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory.');
+    }
+    this.context = context;
+    this.projectId = context.projectId;
+    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;
+    this.originalMessage = context.message;
+
+    this.API_ENDPOINT = context.API_ENDPOINT;
+    this.tdClient = new TiledeskClient({
+      projectId: this.context.projectId,
+      token: this.context.token,
+      APIURL: this.API_ENDPOINT,
+      APIKEY: "___",
+      log: this.log
+    });
+  }
+
+  execute(directive, callback) {
+    let action;
+    if (directive.action) {
+      action = directive.action;
+      if (!action.attributes) {
+        action.attributes = {}
+      }
+      action.attributes.fillParams = true;
+    }
+    else {
+      console.error("Incorrect directive (no action provided):", directive);
+      callback();
+      return;
+    }
+    this.go(action, (stop) => {
+      callback(stop);
+    });
+  }
+
+  async go(action, callback) {
+    if (this.log) { console.log("ReplyV2 action!", JSON.stringify(action)); }
+    const message = action;
+
+    let current; // debug only
+    if (this.log) {
+      if (message.attributes.commands[1].message.text) {
+        current = message.attributes.commands[1].message.text
+      }
+      console.log("current:", current);
+    }
+    let must_stop = false;
+    // fill
+    let requestAttributes = null;
+    if (this.tdcache) {
+      requestAttributes = 
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      );
+      if (this.log) {
+        for (const [key, value] of Object.entries(requestAttributes)) {
+          const value_type = typeof value;
+        }
+      }
+
+      try {
+        // lock/unlock + no-match
+        // get buttons if available
+        const buttons = TiledeskChatbotUtil.allReplyButtons(message);
+        if (this.log) { console.log("Action Buttons:", JSON.stringify(buttons)); }
+        if (buttons && buttons.length > 0) {
+          const locked = await this.lockUnlock(action); // first execution returns locked, then unlocked
+          if (locked) { // fist execution returns (just) locked
+            if (this.log) { console.log("first time pass!"); }
+            must_stop = true; // you must stop after next callbacks (in this flow) if there are buttons
+            // console.log("action:", action);
+            if (action.noInputIntent) {
+              if (this.log) { console.log("NoInputIntent found:", action.noInputIntent); }
+              const noInputIntent = action.noInputIntent;
+              const noInputTimeout = action.noInputTimeout;
+              if (this.log) { console.log("noInputTimeout found:", noInputTimeout); }
+              if (noInputTimeout > 0 && noInputTimeout < 7776000) {
+                const timeout_id = uuidv4();
+                await this.chatbot.addParameter(TiledeskChatbotConst.USER_INPUT, timeout_id); // control variable. On each user input is removed
+                if (this.log) {  console.log("Set userInput: false, checking...", await this.chatbot.getParameter(TiledeskChatbotConst.USER_INPUT)); }
+                setTimeout(async () => {
+                  if (this.log) { console.log("noinput timeout triggered!"); }
+                  const userInput = await this.chatbot.getParameter(TiledeskChatbotConst.USER_INPUT);
+                  if (this.log) {  console.log("got 'userInput':", userInput); }
+                  if (userInput && userInput === timeout_id) {
+                    if (this.log) {  console.log("no 'userInput'. Executing noinput action:", noInputIntent); }
+                    await this.chatbot.unlockIntent(this.requestId);
+                    await this.chatbot.unlockAction(this.requestId);
+                    if (this.log) {  console.log("unlocked (for noInput) ReplyV2"); }
+                    let noinput_action = DirIntent.intentDirectiveFor(noInputIntent, null);
+                    this.intentDir.execute(noinput_action, () => {
+                      if (this.log) {  console.log("noinput action invoked", noinput_action); }
+                    });
+                  }
+                  else {
+                    if (this.log) {  console.log("skipping noinput action because of userInput", userInput); }
+                  }
+                }, noInputTimeout);
+              }
+            }
+          }
+          else { // second execution
+            if (this.log) { console.log("second pass! unlocked!"); }
+            const last_user_text = await this.chatbot.getParameter(TiledeskChatbotConst.REQ_LAST_USER_TEXT_v2_KEY);
+            if (this.log) { console.log("got last user text"); }
+            const button = TiledeskChatbotUtil.buttonByText(last_user_text, buttons);
+            if (this.log) { console.log("button found", JSON.stringify(button)); }
+            // invoke button
+            if (button && button.action) {
+              if (this.log) { console.log("moving to button action", button.action); }
+              let button_action = DirIntent.intentDirectiveFor(button.action, null);
+              if (this.log) { console.log("action with .intentName:", button_action); }
+              this.intentDir.execute(button_action, () => {
+                if (this.log) { console.log("action invoked", button_action); }
+              });
+              if (this.log) { console.log("callback(true) + return", current); }
+              callback(true); // must_stop = true
+              return;
+            }
+            else { // no match (treating text buttons as no-match for the moment)
+              // if noMatchIntent invoke
+              // const button = TiledeskChatbotUtil.buttonByText("nomatch", buttons);
+              if (this.log) { console.log("nomatch button found", JSON.stringify(button)); }
+              // // invoke button
+              // if (button && button.action) {
+              //   console.log("moving to nomatch action", button.action);
+              //   let button_action = DirIntent.intentDirectiveFor(button.action, null);
+              //   this.intentDir.execute(button_action, () => {
+              //     console.log("nomatch action invoked", button_action);
+              //   });
+              //   console.log("callback(true) + return 2", current);
+              //   callback(true);
+              //   return;
+              // }
+              if (action.noMatchIntent) {
+                if (this.log) { console.log("moving to nomatch action", action.noMatchIntent); }
+                let nomatch_action = DirIntent.intentDirectiveFor(action.noMatchIntent, null);
+                this.intentDir.execute(nomatch_action, () => {
+                  if (this.log) { console.log("nomatch action invoked", nomatch_action); }
+                });
+                if (this.log) { console.log("callback(true) + return no-match", current); }
+                callback(true); // must_stop = true
+                return;
+              }
+              else {
+                // const defaultFallbackAction = { action: { intentName: "defaultFallback" } };
+
+                // console.log("re-send original message:",JSON.stringify(this.originalMessage));
+                const messageDir = new DirMessageToBot(this.context);
+                messageDir.execute( { action: { message: this.originalMessage }  }, () => {
+                  if (this.log) { console.log("messageDir invoked"); }
+                });
+                if (this.log) { console.log("callback(true) + return no-match", current); }
+                callback(true); // must_stop = true
+                return;
+
+                // const textAction = { action: { text: last_user_text } };
+                // console.log("textAction invoked:",textAction ); //, defaultFallbackAction);
+                // this.intentDir.execute( textAction, () => {
+                //   if (this.log) { console.log("textAction invoked", textAction); }
+                // });
+                // if (this.log) { console.log("callback(true) + return no-match", current); }
+                // callback(true); // must_stop = true
+                // return;
+
+
+                // // there is no "no-match", go on...
+                // if (this.log) { console.log("callback(false) + return 3", current); }
+                // callback(false);
+                // return;
+              }
+            }
+          }
+        }
+      }
+      catch(error) {
+        console.error("Error in DirReplyV2:", error);
+      }
+
+      
+      if (this.log) { console.log("proceding normally to render and send the reply", current); }
+      const filler = new Filler();
+      // fill text attribute
+      message.text = filler.fill(message.text, requestAttributes);
+      if (message.metadata) {
+        if (this.log) {console.log("filling message 'metadata':", JSON.stringify(message.metadata));}
+        if (message.metadata.src) {
+          message.metadata.src = filler.fill(message.metadata.src, requestAttributes);
+        }
+        if (message.metadata.name) {
+          message.metadata.name = filler.fill(message.metadata.name, requestAttributes);
+        }
+      }
+      if (this.log) {console.log("filling commands'. Message:", JSON.stringify(message));}
+      if (message.attributes && message.attributes.commands) {
+        if (this.log) {console.log("filling commands'. commands found.");}
+        let commands = message.attributes.commands;
+        if (this.log) {console.log("commands:", JSON.stringify(commands), commands.length);}
+        if (commands.length > 0) {
+          if (this.log) {console.log("commands' found");}
+          for (let i = 0; i < commands.length; i++) {
+            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, this.log);
+              if (this.log) {console.log("command filled:", command.message.text);}
+            }
+          }
+        }
+      }
+
+      // EVALUATE EXPRESSION AND REMOVE BASED ON EVALUATION
+      if (this.log) {console.log("message before filters:", JSON.stringify(message));}
+      if (message.attributes && message.attributes.commands) {
+        if (this.log) {console.log("filterOnVariables...on commands", JSON.stringify(message.attributes.commands));}
+        if (this.log) {console.log("filterOnVariables...on attributes", requestAttributes);}
+        // TiledeskChatbotUtil.filterOnVariables(message.attributes.commands, requestAttributes);
+        TiledeskChatbotUtil.filterOnVariables(message, requestAttributes);
+      }
+
+      // temporary send back of reserved attributes
+      if (!message.attributes) {
+        message.attributes = {}
+      }
+      // Reserved names: userEmail, userFullname
+      // if (requestAttributes['userEmail']) {
+      //     message.attributes.updateUserEmail = requestAttributes['userEmail'];
+      // }
+      // if (requestAttributes['userFullname']) {
+      //   message.attributes.updateUserFullname = requestAttributes['userFullname'];
+      // }
+      // intent_info
+      if (this.context.reply && this.context.reply.attributes && this.context.reply.attributes.intent_info) {
+        message.attributes.intentName = this.context.reply.attributes.intent_info.intent_name;
+      }
+      // userFlowAttributes
+      let userFlowAttributes = TiledeskChatbotUtil.userFlowAttributes(requestAttributes);
+      if (this.log) { console.log("userFlowAttributes:", userFlowAttributes); }
+      if (userFlowAttributes) {
+        message.attributes["flowAttributes"] = {};
+        for (const [key, value] of Object.entries(userFlowAttributes)) {
+          try {
+            if(typeof value === 'string' && value.length <= 1000){
+              message.attributes["flowAttributes"][key] = value;
+            }
+          }
+          catch(err) {
+            console.error("An error occurred while JSON.parse(). Parsed value:" + value + " in allParametersStatic(). Error:", err);
+          }
+        }
+      }
+      
+    }
+    // send!
+    let cleanMessage = message;
+    // cleanMessage = TiledeskChatbotUtil.removeEmptyReplyCommands(message);
+    // if (!TiledeskChatbotUtil.isValidReply(cleanMessage)) {
+    //   console.log("invalid message", cleanMessage);
+    //   callback(); // cancel reply operation
+    //   return;
+    // }
+    // console.log("valid message!", cleanMessage);
+    cleanMessage.senderFullname = this.context.chatbot.bot.name;
+    if (this.log) {console.log("Reply:", JSON.stringify(cleanMessage))};
+    await TiledeskChatbotUtil.updateConversationTranscript(this.context.chatbot, cleanMessage);
+    this.tdClient.sendSupportMessage(
+      this.requestId,
+      cleanMessage,
+      (err) => {
+        if (err) {
+          console.error("Error sending reply:", err);
+        }
+        if (this.log) {console.log("Reply message sent");}
+        const delay = TiledeskChatbotUtil.totalMessageWait(cleanMessage);
+        // console.log("got total delay:", delay)
+        if (delay > 0 && delay <= 30000) { // prevent long delays
+          if (this.log) { console.log("start timeout callback(" + must_stop + ") for:", current); }
+          setTimeout(async () => {
+            if (this.log) { console.log("callback(" + must_stop + ") after delay", current); }
+            callback(must_stop);
+          }, delay);
+        }
+        else {
+          // console.log("invalid delay.")
+          callback(must_stop);
+        }
+    });
+
+  }
+
+
+  async lockUnlock(action, callback) {
+    let lockedAction = await this.chatbot.currentLockedAction(this.requestId);
+    // console.log("(DirReplyV2) lockedAction:", lockedAction);
+    if (!lockedAction) {
+      // console.log("(DirReplyV2) !lockedAction");
+      const intent_name = this.reply.attributes.intent_info.intent_name
+      const actionId = action["_tdActionId"];
+      // console.log("(DirReplyV2) intent_name:", intent_name);
+      // console.log("(DirReplyV2) actionId:", actionId);
+      await this.chatbot.lockIntent(this.requestId, intent_name);
+      // console.log("(DirReplyV2) lockIntent");
+      await this.chatbot.lockAction(this.requestId, actionId);
+      // console.log("(DirReplyV2) lockAction");
+      let _lockedAction = await this.chatbot.currentLockedAction(this.requestId);
+      let _lockedIntent = await this.chatbot.currentLockedIntent(this.requestId);
+      // console.log("(DirReplyV2) _lockedAction", _lockedAction);
+      // console.log("(DirReplyV2) _lockedIntent", _lockedIntent);
+      // callback();
+      return true;
+    } else {
+      try {
+        await this.chatbot.unlockIntent(this.requestId);
+        await this.chatbot.unlockAction(this.requestId);
+        // console.log("unlocked ReplyV2");
+        return false;
+      }
+      catch(e) {
+        console.error("Error", e);
+      }
+    }
+  }
+
+}
+
+module.exports = { DirReplyV2 };

package/tiledeskChatbotPlugs/directives/DirSendEmail.js

@@ -2,6 +2,7 @@ const { param } = require('express/lib/request');
 const ms = require('minimist-string');
 const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
 const { Filler } = require('../Filler');
+const { TiledeskClient } = require('@tiledesk/tiledesk-client');
 // const { TiledeskClient } = require('@tiledesk/tiledesk-client');
 
 class DirSendEmail {
@@ -11,29 +12,18 @@ class DirSendEmail {
       throw new Error('context object is mandatory.');
     }
     this.context = context;
-    this.tdclient = context.tdclient;
     this.tdcache = context.tdcache;
     this.requestId = context.requestId;
-    this.log = context.log;
-    // let context =  {
-    //   projectId: projectId,
-    //   token: token,
-    //   supportRequest: supportRequest,
-    //   requestId: supportRequest.request_id,
-    //   TILEDESK_APIURL: API_URL,
-    //   TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
-    //   departmentId: depId,
-    //   tdcache: tdcache,
-    //   log: false
-    // }
-    // this.tdclient = new TiledeskClient({
-    //   projectId: context.projectId,
-    //   token: context.token,
-    //   APIURL: context.TILEDESK_APIURL,
-    //   APIKEY: "___",
-    //   log: context.log
-    // });
-    
+    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: "___",
+      log: this.log
+    });
   }
 
   execute(directive, callback) {
@@ -82,8 +72,8 @@ class DirSendEmail {
             to: filled_to,
             replyto: reply_to
           }
-          console.log("email message:", JSON.stringify(message));
-          const message_echo = await this.tdclient.sendEmail(message);
+          // console.log("email message:", JSON.stringify(message));
+          const message_echo = await this.tdClient.sendEmail(message);
           if (this.log) {console.log("email sent. filled_subject:", filled_subject);}
           if (this.log) {console.log("email sent. filled_text:", filled_text);}
           if (this.log) {console.log("email sent. filled_to:", filled_to);}

package/tiledeskChatbotPlugs/directives/DirSendWhatsapp.js

@@ -0,0 +1,247 @@
+const axios = require("axios").default;
+const { TiledeskChatbot } = require('../../models/TiledeskChatbot');
+const { Filler } = require("../Filler");
+const { DirIntent } = require("./DirIntent");
+
+let whatsapp_api_url;
+
+class DirSendWhatsapp {
+
+  constructor(context) {
+    if (!context) {
+      throw new Error('context object is mandatory');
+    }
+    this.context = context;
+    this.chatbot = context.chatbot;
+    this.tdcache = this.context.tdcache;
+    this.requestId = this.context.requestId;
+    this.intentDir = new DirIntent(context);
+    this.API_ENDPOINT = this.context.API_ENDPOINT;
+    this.log = context.log;
+  }
+
+  execute(directive, callback) {
+    if (this.log) { console.log("DirWhatsappStatic directive: ", directive); }
+    let action;
+    if (directive.action) {
+      action = directive.action;
+    }
+    else {
+      console.error("Incorrect directive: ", JSON.stringify(directive));
+      callback();
+      return;
+    }
+    this.go(action, (stop) => {
+      callback(stop);
+    })
+  }
+
+  async go(action, callback) {
+
+    if (this.log) { console.log("DirWhatsappStatic action: ", JSON.stringify(action)) }
+    if (!this.tdcache) {
+      console.error("Error: DirAskGPT tdcache is mandatory");
+      callback();
+      return;
+    }
+
+    let trueIntent = action.trueIntent;
+    let falseIntent = action.falseIntent;
+
+    let requestVariables = null;
+    requestVariables = 
+      await TiledeskChatbot.allParametersStatic(
+        this.tdcache, this.requestId
+      )
+
+    // Declarations
+    let payload = action.payload;
+
+    const filler = new Filler();
+    
+    // receiver_list will be of just one element, so we can pick up only the first element, if exists.
+    let receiver = payload.receiver_list[0];
+    
+
+    //header_params: text, image, document. NO: location
+    //body_params: text
+    //button_params: text
+    //footer_paramas: non supportati
+
+    receiver = await this.fillWholeReceiver(receiver, requestVariables);
+    payload.receiver_list[0] = receiver;
+    payload.transaction_id = this.context.requestId;
+    payload.broadcast = false;
+    
+    const whatsapp_api_url_pre = process.env.WHATSAPP_ENDPOINT;
+
+    if (whatsapp_api_url_pre) {
+      whatsapp_api_url = whatsapp_api_url_pre;
+    } else {
+      whatsapp_api_url = this.API_ENDPOINT + "/modules/whatsapp/api"
+    }
+    if (this.log) { console.log("DirSendWhatsapp whatsapp_api_url: ", whatsapp_api_url); };
+
+    const HTTPREQUEST = {
+      url: whatsapp_api_url + "/tiledesk/broadcast",
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      json: payload,
+      method: 'POST'
+    }
+
+    if (this.log) { console.log("DirSendWhatsapp HTTPREQUEST:  ", HTTPREQUEST); }
+
+    this.#myrequest(
+      HTTPREQUEST, async (err, resbody) => {
+        if (err) {
+          console.error("DirSendWhatsapp error: ", err);
+          await this.chatbot.addParameter("flowError", "SendWhatsapp Error: " + err);
+          if (callback) {
+            if (falseIntent) {
+              await this.#executeCondition(false, trueIntent, null, falseIntent, null);
+              callback(true);
+              return;
+            }
+            callback();
+            return;
+          }
+        } else if (resbody.success === true) {
+          if (callback) {
+            if (trueIntent) {
+              await this.#executeCondition(true, trueIntent, null, falseIntent, null);
+              callback(true);
+              return;
+            }
+            callback();
+            return;
+          }
+        } else {
+          if (this.log) { console.log("DirSendWhatsapp unexpected resbody: ", resbody); }
+          if (callback) {
+            if (falseIntent) {
+              await this.#executeCondition(false, trueIntent, null, falseIntent, null);
+              callback(true);
+              return
+            }
+            callback();
+            return;
+          }
+        }
+      }
+    )
+  }
+
+  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, () => {
+          if (callback) {
+            callback();
+          }
+        })
+      }
+      else {
+        if (this.log) { console.log("No trueIntentDirective specified"); }
+        if (callback) {
+          callback();
+        }
+      }
+    }
+    else {
+      if (falseIntentDirective) {
+        this.intentDir.execute(falseIntentDirective, () => {
+          if (callback) {
+            callback();
+          }
+        });
+      }
+      else {
+        if (this.log) { console.log("No falseIntentDirective specified"); }
+        if (callback) {
+          callback();
+        }
+      }
+    }
+  }
+
+  async fillWholeReceiver(receiver, requestVariables) {
+    return new Promise((resolve) => {
+
+      const filler = new Filler();
+      try {
+        receiver.phone_number = filler.fill(receiver.phone_number, requestVariables);
+        if (receiver.header_params) {
+          receiver.header_params.forEach(p => {
+            if (p.type === 'TEXT') {
+              p.text = filler.fill(p.text, requestVariables)
+            } 
+            else if (p.type === 'IMAGE') {
+              p.image.link = filler.fill(p.image.link, requestVariables)
+            }
+            else if (p.type === 'DOCUMENT') {
+              p.document.link = filler.fill(p.document.link, requestVariables)
+            }
+          })
+        }
+    
+        if (receiver.body_params) {
+          receiver.body_params.forEach(p => {
+            p.text = filler.fill(p.text, requestVariables)
+          })
+        }
+    
+        if (receiver.buttons_params) {
+          receiver.buttons_params.forEach(p => {
+            p.text = filler.fill(p.text, requestVariables)
+          })
+        }
+
+        resolve(receiver);
+
+      } catch(err) {
+        console.error("DirSendWhatsapp fillWholeReceiver error: ", err)
+        resolve(null);
+      }
+
+    })
+  }
+
+  // HTTP REQUEST
+  async #myrequest(options, callback, log) {
+    return await axios({
+      url: options.url,
+      method: options.method,
+      data: options.json,
+      params: options.params,
+      headers: options.headers
+    }).then((res) => {
+      if (res && res.status == 200 && res.data) {
+        if (callback) {
+          callback(null, res.data);
+        }
+      }
+      else {
+        if (callback) {
+          callback(TiledeskClient.getErr({ message: "Response status not 200" }, options, res), null, null);
+        }
+      }
+    }).catch((err) => {
+      console.error("(tybot request) An error occured: ", err);
+      if (callback) {
+        callback(err, null, null);
+      }
+    })
+  }
+}
+
+module.exports = { DirSendWhatsapp }