@tiledesk/tiledesk-tybot-connector 2.0.38 → 2.0.40

package/engine/TiledeskChatbot.js

@@ -18,9 +18,9 @@ class TiledeskChatbot {
     if (!config.botsDataSource) {
       throw new Error("config.botsDataSource is mandatory");
     }
-    if (!config.intentsFinder) {
-      throw new Error("config.intentsFinder is mandatory");
-    }
+    // if (!config.intentsFinder) {
+    //   throw new Error("config.intentsFinder is mandatory");
+    // }
     if (!config.botId) {
       throw new Error("config.botId is mandatory");
     }
@@ -253,6 +253,63 @@ class TiledeskChatbot {
       }
     });
   }
+
+  async findBlock(message, callback) {
+    return new Promise( async (resolve, reject) => {
+      let lead = null;
+      if (message.request) {
+        this.request = message.request;
+      }
+      
+      let explicit_intent_name = null;
+      // Explicit intent invocation
+      if (message.text && message.text.startsWith("/")) {
+        winston.verbose("(TiledeskChatbot) Intent was explicitly invoked: " + message.text);
+        let intent_name = message.text.substring(message.text.indexOf("/") + 1);
+        winston.verbose("(TiledeskChatbot) Invoked Intent: " + intent_name)
+        explicit_intent_name = intent_name;
+      }
+      
+      // Intent invocation with action
+      if (message.attributes && message.attributes.action) {
+        winston.debug("(TiledeskChatbot) Message has action: ", message.attributes.action)
+        explicit_intent_name = message.attributes.action;
+        winston.verbose("(TiledeskChatbot) Intent was explicitly invoked with an action:", explicit_intent_name)
+      }
+
+      if (explicit_intent_name) {
+        winston.verbose("(TiledeskChatbot) Processing explicit intent:", explicit_intent_name)
+        // look for parameters
+        const intent = TiledeskChatbotUtil.parseIntent(explicit_intent_name);
+        winston.debug("(TiledeskChatbot) parsed intent:", intent);
+        let reply;
+        if (!intent || (intent && !intent.name)) {
+          winston.verbose("(TiledeskChatbot) Invalid intent:", explicit_intent_name)
+          reply = { "text": "Invalid intent: *" + explicit_intent_name + "*" }
+          resolve();
+        }
+        else {
+          winston.verbose("(TiledeskChatbot) Processing intent:", explicit_intent_name)
+          let faq = await this.botsDataSource.getByIntentDisplayNameCache(this.botId, intent.name, this.tdcache);
+          // console.log("faq: ", JSON.stringify(faq, null, 2))
+
+          if (faq) {
+            if (faq.actions) {
+              // Qui viene aggiornata faq perchè l'oggetto in js viene passato per riferimento. Viene modificato l'oggetto originale anche senza un return.
+              TiledeskChatbotUtil.addConnectAction(faq);
+            }
+            resolve(faq)
+            return;
+          }
+          else {
+            winston.verbose("(TiledeskChatbot) Intent not found: " + explicit_intent_name);
+            reply = { "text": "Intent not found: " + explicit_intent_name }
+            resolve()
+          }
+        }
+      }
+    });
+  }
   
   async execIntent(faq, message, lead) {//, bot) {
     let answerObj = faq; // faqs[0];

package/engine/mock/MockBotsDataSource.js

@@ -38,7 +38,7 @@ class MockBotsDataSource {
    * @returns an Array of matches
    */
   async getByExactMatch(botId, text) {
-    const intent_display_name = this.data.bots[botId].questions_intent[text];
+    const intent_display_name = this.data.bots[botId].questions_intent?.[text];
     if (intent_display_name) {
       return [this.data.bots[botId].intents[intent_display_name]];
     }

package/index.js

@@ -44,6 +44,7 @@ let staticBots;
 router.post('/ext/:botid', async (req, res) => {
   const botId = req.params.botid;
   winston.verbose("(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'"})
   }
@@ -133,9 +134,14 @@ router.post('/ext/:botid', async (req, res) => {
   });
   winston.verbose("(tybotRoute) Message text: " + message.text)
   
-  await TiledeskChatbotUtil.updateRequestAttributes(chatbot, token, message, projectId, requestId);
-  if (requestId.startsWith("support-group-")) {
-    await TiledeskChatbotUtil.updateConversationTranscript(chatbot, message);
+  try {
+    await TiledeskChatbotUtil.updateRequestAttributes(chatbot, token, message, projectId, requestId);
+    if (requestId.startsWith("support-group-")) {
+      await TiledeskChatbotUtil.updateConversationTranscript(chatbot, message);
+    }
+  } catch (e) {
+    winston.error("Error on /ext updating request attributes or transcript: ", e)
+    return;
   }
 
   let reply = null;
@@ -199,6 +205,151 @@ router.post('/ext/:botid', async (req, res) => {
   
 });
 
+router.post('/exec/:botid', async (req, res) => {
+  
+  const botId = req.params.botid;
+  winston.verbose("(tybotRoute) POST /exec/: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;
+  }
+  winston.verbose("(tybotRoute) Request Body: ", req.body);
+
+  const message = req.body.payload;
+  const messageId = message._id;
+  const token = req.body.token;
+  const requestId = message.request.request_id;
+  const projectId = message.id_project;
+  winston.verbose("(tybotRoute) message.id_project: " + message.id_project)
+
+  // adding info for internal context workflow
+  message.request.bot_id = botId;
+  if (message.request.id_project === null || message.request.id_project === undefined) {
+    message.request.id_project = projectId;
+  }
+
+  //skip internal note messages
+  if(message && message.attributes && message.attributes.subtype === 'private') {
+    winston.verbose("(tybotRoute) Skipping internal note message: " + message.text);
+    return res.status(200).send({"success":true});
+  }
+
+  // validate reuqestId
+  let isValid = TiledeskChatbotUtil.validateRequestId(requestId, projectId);
+  if (isValid) {
+    res.status(200).send({"success":true});
+  }
+  else {
+    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;
+  await tdcache.set(
+    request_botId_key,
+    botId,
+    {EX: 604800} // 7 days
+  );
+
+  let botsDS;
+  if (!staticBots) {
+    botsDS = new MongodbBotsDataSource({projectId: projectId, botId: botId});
+    winston.verbose("(tybotRoute) botsDS created with Mongo");
+  }
+  else {
+    botsDS = new MockBotsDataSource(staticBots);
+  }
+
+  // get the bot metadata
+  let bot = await botsDS.getBotByIdCache(botId, tdcache).catch((err)=> {
+    Promise.reject(err);
+    return;
+  });
+
+  let intentsMachine;
+  let backupMachine;
+
+  const chatbot = new TiledeskChatbot({
+    botsDataSource: botsDS,
+    intentsFinder: intentsMachine,
+    backupIntentsFinder: backupMachine,
+    botId: botId,
+    bot: bot,
+    token: token,
+    APIURL: API_ENDPOINT,
+    APIKEY: "___",
+    tdcache: tdcache,
+    requestId: requestId,
+    projectId: projectId,
+    MAX_STEPS: MAX_STEPS,
+    MAX_EXECUTION_TIME: MAX_EXECUTION_TIME
+  });
+  winston.verbose("(tybotRoute) Message text: " + message.text);
+
+  let reply = null;
+  try {
+    reply = await chatbot.findBlock(message);
+  } 
+  catch (err) {
+    winston.error("(tybotRoute) An error occurred replying to message: ", err);
+    return;
+  }
+  if (!reply) {
+    winston.verbose("(tybotRoute) No reply. Stop flow.")
+    return;
+  }
+
+  if (reply.actions && reply.actions.length > 0) { // structured actions (coming from chatbot designer)
+    try {
+      winston.debug("(tybotRoute) Reply actions: ", reply.actions)
+      let directives = TiledeskChatbotUtil.actionsToDirectives(reply.actions);
+      winston.debug("(tybotRoute) the directives:", directives)
+      let directivesPlug = new DirectivesChatbotPlug(
+        {
+          message: message,
+          reply: reply,
+          directives: directives,
+          chatbot: chatbot,
+          supportRequest: message.request,
+          API_ENDPOINT: API_ENDPOINT,
+          TILEBOT_ENDPOINT:TILEBOT_ENDPOINT,
+          token: token,
+          // HELP_CENTER_API_ENDPOINT: process.env.HELP_CENTER_API_ENDPOINT,
+          cache: tdcache
+        }
+      );
+      directivesPlug.processDirectives( () => {
+        winston.verbose("(tybotRoute) Actions - Directives executed.");
+      });
+    }
+    catch (error) {
+      winston.error("(tybotRoute) Error while processing actions:", error);
+    }
+  }
+  else { // text answer (parse text directives to get actions)
+    winston.verbose("(tybotRoute) No actions. Reply text: ", reply.text)
+    reply.triggeredByMessageId = messageId;
+    if (!reply.attributes) {
+      reply.attributes = {}
+    }
+    reply.attributes.directives = true;
+    reply.attributes.splits = true;
+    reply.attributes.markbot = true;
+    reply.attributes.fillParams = true;
+    
+    const apiext = new ExtApi({
+      TILEBOT_ENDPOINT: TILEBOT_ENDPOINT
+    });
+    apiext.sendSupportMessageExt(reply, projectId, requestId, token, () => {
+      winston.verbose("(tybotRoute) sendSupportMessageExt reply sent: ", reply)
+    });
+  }
+
+})
+
 router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) => {
   res.json({success:true});
   const projectId = req.params.projectId;