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

package/index.js

@@ -12,6 +12,8 @@ const { MongodbBotsDataSource } = require('./models/MongodbBotsDataSource.js');
 const { MockBotsDataSource } = require('./models/MockBotsDataSource.js');
 const { TiledeskChatbotConst } = require('./models/TiledeskChatbotConst');
 const { IntentsMachineFactory } = require('./models/IntentsMachineFactory');
+const { v4: uuidv4 } = require('uuid');
+let axios = require('axios');
 // let parser = require('accept-language-parser');
 
 router.use(bodyParser.json({limit: '50mb'}));
@@ -19,6 +21,8 @@ router.use(bodyParser.urlencoded({ extended: true , limit: '50mb'}));
 
 let log = false;
 let tdcache = null;
+let MAX_STEPS = 1000;
+let MAX_EXECUTION_TIME = 1000 * 3600 * 8;
 
 // DEV
 // const { MessagePipeline } = require('./tiledeskChatbotPlugs/MessagePipeline');
@@ -28,18 +32,23 @@ 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');
-let APIURL = null;
+let API_ENDPOINT = null;
+let TILEBOT_ENDPOINT = null;
 let staticBots;
 
 router.post('/ext/:botid', async (req, res) => {
+  const botId = req.params.botid;
+  if (log) {console.log("(tybotRoute) POST /ext/:botid called: ", botId);}
+  if(!botId || botId === "null" || botId === "undefined"){
+    return res.status(400).send({"success": false, error: "Required parameters botid not found. Value is 'null' or 'undefined'"})
+  }
+
   if (req && req.body && req.body.payload && req.body.payload.request && req.body.payload.request.snapshot) {
     delete req.body.payload.request.snapshot;
     console.log("Removed req.body.payload.request.snapshot field");
   }
   if (log) {console.log("REQUEST BODY:", JSON.stringify(req.body));}
-  
-  const botId = req.params.botid;
-  if (log) {console.log(" :", botId);}
+
   const message = req.body.payload;
   const messageId = message._id;
   //const faq_kb = req.body.hook; now it is "bot"
@@ -68,9 +77,8 @@ router.post('/ext/:botid', async (req, res) => {
     res.status(200).send({"success":true});
   }
   else {
-    res.status(400).send({"success": false, error: "Request id is invalid"});
-    // console.log("request id, projectId:", requestId, projectId)
-    // process.exit(0)
+    res.status(400).send({"success": false, error: "Request id is invalid:" + requestId + " for projectId:" + projectId + "chatbotId:" + botId});
+    return;
   }
 
   const request_botId_key = "tilebot:botId_requests:" + requestId;
@@ -107,19 +115,23 @@ router.post('/ext/:botid', async (req, res) => {
   }
   
   // get the bot metadata
-  let bot = null;
-  try {
-    // bot = await botsDS.getBotById(botId);
-    // bot = await botById(botId, projectId, tdcache, botsDS);
-    bot = await botsDS.getBotByIdCache(botId, tdcache);
-    // console.log("getBotByIdCache ---> bot: ", JSON.stringify(bot, null, 2))
-  }
-  catch(error) {
-    console.error("Error getting botId:", botId);
-    console.error("Error getting bot was:", error);
+  let bot = await botsDS.getBotByIdCache(botId, tdcache).catch((err)=> {
+    Promise.reject(err);
     return;
-  }
-  if (log) {console.log("bot found:", JSON.stringify(bot));}
+  });
+  // let bot = null;
+  // try {
+  //   // bot = await botsDS.getBotById(botId);
+  //   // bot = await botById(botId, projectId, tdcache, botsDS);
+  //   bot = await botsDS.getBotByIdCache(botId, tdcache);
+  //   // console.log("getBotByIdCache ---> bot: ", JSON.stringify(bot, null, 2))
+  // }
+  // catch(error) {
+  //   console.error("Error getting botId:", botId);
+  //   console.error("Error getting bot was:", error);
+  //   return;
+  // }
+  // if (log) {console.log("bot found:", JSON.stringify(bot));}
   
   let intentsMachine;
   let backupMachine;
@@ -159,11 +171,13 @@ router.post('/ext/:botid', async (req, res) => {
     botId: botId,
     bot: bot,
     token: token,
-    APIURL: APIURL,
+    APIURL: API_ENDPOINT,
     APIKEY: "___",
     tdcache: tdcache,
     requestId: requestId,
     projectId: projectId,
+    MAX_STEPS: MAX_STEPS,
+    MAX_EXECUTION_TIME: MAX_EXECUTION_TIME,
     log: log
   });
   if (log) {console.log("MESSAGE CONTAINS:", message.text);}
@@ -171,20 +185,22 @@ router.post('/ext/:botid', async (req, res) => {
   //   if (log) {console.log("forced conversion of \\\\start /start");}
   //   message.text = "/start";
   // }
-  await TiledeskChatbotUtil.updateRequestAttributes(chatbot, message, projectId, requestId);
-  await TiledeskChatbotUtil.updateConversationTranscript(chatbot, message);
+  await TiledeskChatbotUtil.updateRequestAttributes(chatbot, token, message, projectId, requestId);
+  if (requestId.startsWith("support-group-")) {
+    await TiledeskChatbotUtil.updateConversationTranscript(chatbot, message);
+  }
 
   let reply = null;
   try {
     reply = await chatbot.replyToMessage(message);
   }
   catch(err) {
-    console.error("An error occurred replying to message:", JSON.stringify(message), "\nError:", err );
+    console.error("(tybotRoute) An error occurred replying to message:", JSON.stringify(message), "\nError:", err );
+    return;
   }
   if (!reply) {
-    reply = {
-      "text": "No messages found. Is 'defaultFallback' intent missing?"
-    }
+    if (log) { console.log("(tybotRoute) No reply. Stop flow.") }
+    return;
   }
   
   // console.log("reply is:", reply);
@@ -203,11 +219,11 @@ router.post('/ext/:botid', async (req, res) => {
           directives: directives,
           chatbot: chatbot,
           supportRequest: message.request,
-          TILEDESK_API_ENDPOINT: APIURL,
-          TILEBOT_ENDPOINT:process.env.TYBOT_ENDPOINT,
+          API_ENDPOINT: API_ENDPOINT,
+          TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
           token: token,
           log: log,
-          HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT,
+          // HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT,
           cache: tdcache
         }
       );
@@ -229,12 +245,9 @@ router.post('/ext/:botid', async (req, res) => {
     reply.attributes.splits = true;
     reply.attributes.markbot = true;
     reply.attributes.fillParams = true;
-    let extEndpoint = `${APIURL}/modules/tilebot/`;
-    if (process.env.TYBOT_ENDPOINT) {
-      extEndpoint = `${process.env.TYBOT_ENDPOINT}`;
-    }
+    
     const apiext = new ExtApi({
-      ENDPOINT: extEndpoint,
+      TILEBOT_ENDPOINT: TILEBOT_ENDPOINT,
       log: false
     });
     apiext.sendSupportMessageExt(reply, projectId, requestId, token, () => {
@@ -261,7 +274,7 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
   const tdclient = new TiledeskClient({
     projectId: projectId,
     token: token,
-    APIURL: APIURL,
+    APIURL: API_ENDPOINT,
     APIKEY: "___",
     log: false
   });
@@ -306,10 +319,10 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
   }
   if (log) {
     console.log("/ext request....", JSON.stringify(request));
-    console.log("/ext APIURL....", APIURL);
-    console.log("/ext process.env.TYBOT_ENDPOINT....", process.env.TYBOT_ENDPOINT);
+    console.log("/ext API_ENDPOINT....", API_ENDPOINT);
+    console.log("/ext process.env.TILEBOT_ENDPOINT....", TILEBOT_ENDPOINT);
   }
-  let directivesPlug = new DirectivesChatbotPlug({supportRequest: request, TILEDESK_API_ENDPOINT: APIURL, TILEBOT_ENDPOINT:process.env.TYBOT_ENDPOINT, token: token, log: log, HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT, cache: tdcache});
+  let directivesPlug = new DirectivesChatbotPlug({supportRequest: request, API_ENDPOINT: API_ENDPOINT, TILEBOT_ENDPOINT: TILEBOT_ENDPOINT, token: token, log: log, HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT, cache: tdcache});
   // let directivesPlug = null;
   // PIPELINE-EXT
   // if (log) {console.log("answer to process:", JSON.stringify(answer));}
@@ -329,7 +342,7 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
     tdclient.sendSupportMessage(requestId, bot_answer, (err, response) => {
       if (log) {console.log("/ext => bot_answer sent:", JSON.stringify(bot_answer));}
       if (err) {
-        console.error("/ext => Error sending message", err);
+        console.error("/ext => Error sending message", JSON.stringify(err));
       }
       directivesPlug.processDirectives( () => {
         if (log) {console.log("After message - Directives executed.");}
@@ -358,8 +371,103 @@ router.get('/message/context/:messageid', async (req, res) => {
   }
 });
 
+router.get('/ext/reserved/parameters/requests/:requestid', async (req, res) => {
+  const requestId = req.params.requestid;
+  const parameters = await TiledeskChatbot.allParametersStatic(tdcache, requestId);
+  if (parameters === null) {
+    res.send([]);
+    return;
+  }
+  if (req.query.all != null) {
+    res.send(parameters);
+  }
+  else {
+    // const RESERVED = [
+    //   TiledeskChatbotConst.REQ_CHATBOT_NAME_KEY,
+    //   TiledeskChatbotConst.REQ_CHAT_URL,
+    //   TiledeskChatbotConst.REQ_CITY_KEY,
+    //   TiledeskChatbotConst.REQ_COUNTRY_KEY,
+    //   TiledeskChatbotConst.REQ_DEPARTMENT_ID_KEY,
+    //   TiledeskChatbotConst.REQ_DEPARTMENT_NAME_KEY,
+    //   TiledeskChatbotConst.REQ_END_USER_ID_KEY,
+    //   TiledeskChatbotConst.REQ_END_USER_IP_ADDRESS_KEY,
+    //   TiledeskChatbotConst.REQ_LAST_MESSAGE_ID_KEY,
+    //   TiledeskChatbotConst.REQ_LAST_USER_TEXT_KEY,
+    //   TiledeskChatbotConst.REQ_PROJECT_ID_KEY,
+    //   TiledeskChatbotConst.REQ_REQUEST_ID_KEY,
+    //   TiledeskChatbotConst.REQ_USER_AGENT_KEY,
+    //   TiledeskChatbotConst.REQ_USER_LANGUAGE_KEY,
+    //   TiledeskChatbotConst.REQ_USER_SOURCE_PAGE_KEY,
+    //   TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_TYPE_KEY,
+    //   TiledeskChatbotConst.REQ_TRANSCRIPT_KEY,
+    //   TiledeskChatbotConst.REQ_LAST_USER_MESSAGE_KEY,
+    //   TiledeskChatbot.REQ_DECODED_JWT_KEY,
+    //   "lastUserImageURL", // image
+    //   "lastUserImageName", // image
+    //   "lastUserImageWidth", // image
+    //   "lastUserImageHeight", // image
+    //   "lastUserImageType", // image
+    //   "lastUserDocumentURL", // file
+    //   "lastUserDocumentName", // file
+    //   "lastUserDocumentType", // file
+    //   "ticketId",
+    //   TiledeskChatbotConst.REQ_CHAT_CHANNEL,
+    //   "user_lead_id",
+    //   "lastUserText",
+    //   TiledeskChatbotConst.REQ_REQUESTER_IS_AUTHENTICATED_KEY,
+    //   "userInput"
+    // ]
+    // let userParams = {};
+    // if (parameters) {
+    //   for (const [key, value] of Object.entries(parameters)) {
+    //     // console.log(key, value);
+    //     // There is a bug that moves the requestId as a key in request attributes, so: && !key.startsWith("support-group-")
+    //     if (!key.startsWith("_") && !RESERVED.some(e => e === key) && !key.startsWith("support-group-")) {
+    //       userParams[key] = value;
+    //     }
+    //   }
+    // }
+    const userParams = TiledeskChatbotUtil.userFlowAttributes(parameters);
+    res.send(userParams);
+  }
+});
+
 router.get('/ext/parameters/requests/:requestid', async (req, res) => {
+  // console.log("Checking authorization...");
+  // const authorization = req.headers["authorization"];
+  // if (!authorization) {
+  //   console.log("No authorization header...");
+  //   res.status(401).send("Unauthorized");
+  //   return;
+  // }
+  // const token = req.headers["authorization"];
+  // const publicKey = process.env.GLOBAL_SECRET_OR_PUB_KEY;
+  // console.log("Got public key:", publicKey);
+  // const _decoded = null;
+  // jwt.verify(token, publicKey, function (err, decoded) {
+  //   _decoded = decoded;
+  // });
+  // console.log("Authorization header field checking", req.headers["authorization"]);
+  
+
   const requestId = req.params.requestid;
+  if (!requestId) {
+    res.status(404).send("Not found");
+    return;
+  }
+  const request_parts = requestId.split("-");
+  if (request_parts && request_parts.length >= 4) {
+    const project_id = request_parts[2];
+    // console.log("ProjectId:", project_id);
+    if (project_id !== "656054000410fa00132e5dcc") { //&& project_id !== "ANOTHER P_ID"
+      res.status(401).send("Unauthorized");
+      return;
+    }
+  }
+  else if (!request_parts || ( request_parts && request_parts.length < 4) ) {
+    res.status(500).send("Invalid request ID");
+    return;
+  }
   const parameters = await TiledeskChatbot.allParametersStatic(tdcache, requestId);
   if (parameters === null) {
     res.send([]);
@@ -371,6 +479,7 @@ router.get('/ext/parameters/requests/:requestid', async (req, res) => {
   else {
     const RESERVED = [
       TiledeskChatbotConst.REQ_CHATBOT_NAME_KEY,
+      TiledeskChatbotConst.REQ_CHATBOT_ID_KEY,
       TiledeskChatbotConst.REQ_CHAT_URL,
       TiledeskChatbotConst.REQ_CITY_KEY,
       TiledeskChatbotConst.REQ_COUNTRY_KEY,
@@ -443,7 +552,7 @@ router.post('/echobot', (req, res) => {
   const tdclient = new TiledeskClient({
     projectId: projectId,
     token: token,
-    APIURL: APIURL,
+    APIURL: API_ENDPOINT,
     APIKEY: "___",
     log: false
   });
@@ -464,9 +573,49 @@ router.post('/echobot', (req, res) => {
   });
 });
 
+// draft webhook
+router.post('/block/:project_id/:bot_id/:block_id', async (req, res) => {
+  const project_id = req.params['project_id'];
+  const bot_id = req.params['bot_id'];
+  const block_id = req.params['block_id'];
+  const body = req.body;
+  if (this.log) {
+    console.log("/block/ .heders:", JSON.stringify(req.headers));
+    console.log("/block/ .body:", JSON.stringify(body));
+  }
+  
+  // console.log('/block/:project_id/:bot_id/:block_id:', project_id, "/", bot_id, "/", block_id);
+  // console.log('/block/:project_id/:bot_id/:block_id.body', body);
+  
+  // invoke block
+  // unique ID for each execution
+  const execution_id = uuidv4().replace(/-/g, '');
+  const request_id = "automation-request-" + project_id + "-" + execution_id;
+  const command = "/" + block_id;
+  let request = {
+    "payload": {
+      "recipient": request_id,
+      "text": command,
+      "id_project": project_id,
+      "request": {
+        "request_id": request_id
+      },
+      "attributes": {
+        "payload": body
+      }
+    },
+    "token": "NO-TOKEN"
+  }
+  if (this.log) {console.log("sendMessageToBot()...", JSON.stringify(request));}
+  sendMessageToBot(TILEBOT_ENDPOINT, request, bot_id, async () => {
+    res.status(200).send({"success":true});
+    return;
+  });
+});
+
 async function startApp(settings, completionCallback) {
   console.log("Starting Tilebot...");
-  //console.log("Starting Tilebot with Settings:", settings);
+  // console.log("Starting Tilebot with Settings:", settings);
   if (settings.bots) { // static bots data source
     staticBots = settings.bots;
   }
@@ -480,10 +629,19 @@ async function startApp(settings, completionCallback) {
     throw new Error("settings.API_ENDPOINT is mandatory id no settings.bots.");
   }
   else {
-    APIURL = settings.API_ENDPOINT;
-    console.log("(Tilebot) settings.API_ENDPOINT:", APIURL);
+    API_ENDPOINT = settings.API_ENDPOINT;
+    console.log("(Tilebot) settings.API_ENDPOINT:", API_ENDPOINT);
   }
 
+  if (!settings.TILEBOT_ENDPOINT) {
+    TILEBOT_ENDPOINT = `${API_ENDPOINT}/modules/tilebot`
+  }
+  else {
+    TILEBOT_ENDPOINT = settings.TILEBOT_ENDPOINT
+  }
+  console.log("(Tilebot) settings.TILEBOT_ENDPOINT:", TILEBOT_ENDPOINT);
+
+
   if (settings.REDIS_HOST && settings.REDIS_PORT) {
     tdcache = new TdCache({
       host: settings.REDIS_HOST,
@@ -499,6 +657,19 @@ async function startApp(settings, completionCallback) {
     log = true;
   }
   console.log("(Tilebot) log:", log);
+
+
+  if (process.env.CHATBOT_MAX_STEPS) {
+    MAX_STEPS = Number(process.env.CHATBOT_MAX_STEPS);
+  }
+
+  if (process.env.CHATBOT_MAX_EXECUTION_TIME) {
+    MAX_EXECUTION_TIME = Number(process.env.CHATBOT_MAX_EXECUTION_TIME);// test // prod1000 * 3600 * 4; // 4 hours
+  }
+
+  console.log("(Tilebot) MAX_STEPS: ", MAX_STEPS)
+  console.log("(Tilebot) MAX_EXECUTION_TIME: ", MAX_EXECUTION_TIME)
+
   var pjson = require('./package.json');
   console.log("(Tilebot) Starting Tilebot connector v" + pjson.version);
 
@@ -580,4 +751,80 @@ async function checkRequest(request_id, id_project) {
   // WARNING! Move this function in models/TiledeskChatbotUtil.js
 }
 
+/**
+ * A stub to send message to the "ext/botId" endpoint, hosted by tilebot on:
+ * /${TILEBOT_ROUTE}/ext/${botId}
+ *
+ * @param {Object} message. The message to send
+ * @param {string} botId. Tiledesk botId
+ * @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 = {
+    url: url,
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    json: message,
+    method: 'POST'
+  };
+  myrequest(
+    HTTPREQUEST,
+    function (err, resbody) {
+      if (err) {
+        if (callback) {
+          callback(err);
+        }
+      }
+      else {
+        if (callback) {
+          callback(null, resbody);
+        }
+      }
+    }, false
+  );
+}
+
+function myrequest(options, callback, log) {
+  if (log) {
+    console.log("API URL:", options.url);
+    console.log("** Options:", JSON.stringify(options));
+  }
+  axios(
+    {
+      url: options.url,
+      method: options.method,
+      data: options.json,
+      params: options.params,
+      headers: options.headers
+    })
+    .then((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(TiledeskClient.getErr({ message: "Response status not 200" }, options, res), null, null);
+        }
+      }
+    })
+    .catch((error) => {
+      console.error("(tybotRoute index) An error occurred:", JSON.stringify(error), "url:", options.url);
+      if (callback) {
+        callback(error, null, null);
+      }
+    }
+  );
+}
+
 module.exports = { router: router, startApp: startApp};