@tiledesk/tiledesk-tybot-connector 0.5.0 → 0.5.1-rc1

package/index.js

@@ -1,17 +1,16 @@
 const express = require('express');
 const router = express.Router();
 const bodyParser = require('body-parser');
+const winston = require('./utils/winston.js')
 const { TiledeskClient } = require('@tiledesk/tiledesk-client');
 const { ExtApi } = require('./ExtApi.js');
 const { ExtUtil } = require('./ExtUtil.js');
 const { TdCache } = require('./TdCache.js');
-const { TiledeskChatbot } = require('./models/TiledeskChatbot.js');
-const { MongodbBotsDataSource } = require('./models/MongodbBotsDataSource.js');
-// const { MongodbIntentsMachine } = require('./models/MongodbIntentsMachine.js');
-// const { TiledeskIntentsMachine } = require('./models/TiledeskIntentsMachine.js');
-const { MockBotsDataSource } = require('./models/MockBotsDataSource.js');
-const { TiledeskChatbotConst } = require('./models/TiledeskChatbotConst');
-const { IntentsMachineFactory } = require('./models/IntentsMachineFactory');
+const { TiledeskChatbot } = require('./engine/TiledeskChatbot.js');
+const { MongodbBotsDataSource } = require('./engine/MongodbBotsDataSource.js');
+const { MockBotsDataSource } = require('./engine/mock/MockBotsDataSource.js');
+const { TiledeskChatbotConst } = require('./engine/TiledeskChatbotConst.js');
+const { IntentsMachineFactory } = require('./engine/IntentsMachineFactory.js');
 const { v4: uuidv4 } = require('uuid');
 let axios = require('axios');
 // let parser = require('accept-language-parser');
@@ -32,24 +31,26 @@ const { DirectivesChatbotPlug } = require('./tiledeskChatbotPlugs/DirectivesChat
 // THE IMPORT
 let mongoose = require('mongoose');
 // const { Directives } = require('./tiledeskChatbotPlugs/directives/Directives.js');
-const { TiledeskChatbotUtil } = require('./models/TiledeskChatbotUtil.js'); //require('@tiledesk/tiledesk-chatbot-util');
-const AiService = require('./TiledeskServices/AIService.js');
+const { TiledeskChatbotUtil } = require('./utils/TiledeskChatbotUtil.js'); //require('@tiledesk/tiledesk-chatbot-util');
+
+const AiService = require('./services/AIService.js');
+const tilebotService = require('./services/TilebotService.js');
+
 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);}
+  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'"})
   }
 
   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));}
+  winston.verbose("(tybotRoute) Request Body: ", req.body);
 
   const message = req.body.payload;
   const messageId = message._id;
@@ -57,7 +58,7 @@ router.post('/ext/:botid', async (req, res) => {
   const token = req.body.token;
   const requestId = message.request.request_id;
   const projectId = message.id_project;
-  if (log) {console.log("message.id_project:", message.id_project);}
+  winston.verbose("(tybotRoute) message.id_project: " + message.id_project)
 
   // adding info for internal context workflow
   message.request.bot_id = botId;
@@ -74,7 +75,7 @@ router.post('/ext/:botid', async (req, res) => {
   let isAudio = TiledeskChatbotUtil.isAudioMessage(message)
   if(isAudio){
     let responseText = await aiService.speechToText(message.metadata.src).catch(err => {
-      if(log) console.log('(index.js) aiService.speechToText error: ', err)
+      winston.error('(index.js) aiService.speechToText error: ', err)
     })
     if(responseText && responseText.text)
       message.text = responseText.text
@@ -97,30 +98,13 @@ router.post('/ext/:botid', async (req, res) => {
     {EX: 604800} // 7 days
   );
 
-  // NEXTTTTTTT
-  // const message_context = {
-  //   projectId: projectId,
-  //   requestId: requestId,
-  //   token: token
-  // }
-  // const message_context_key = "tiledesk:messages:context:" + messageId;
-  // await tdcache.set(
-  //   message_context_key,
-  //   JSON.stringify(message_context),
-  //   {EX: 86400}
-  // );
-  // if (log) {console.log("message context saved for messageid:", message_context_key)}
-  // provide a http method for set/get message context, authenticated with tiledesk token and APIKEY.
-  // NEXTTTTTTT
-
   let botsDS;
   if (!staticBots) {
     botsDS = new MongodbBotsDataSource({projectId: projectId, botId: botId, log: log});
-    if (log) {console.log("botsDS created with Mongo");}
+    winston.verbose("(tybotRoute) botsDS created with Mongo");
   }
   else {
     botsDS = new MockBotsDataSource(staticBots);
-    // console.log("botDA.data.........", botsDS.data);
   }
   
   // get the bot metadata
@@ -128,51 +112,21 @@ router.post('/ext/:botid', async (req, res) => {
     Promise.reject(err);
     return;
   });
-  // 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));}
+
+  winston.debug("(tybotRoute) Bot found: ", bot)
+  
   
   let intentsMachine;
   let backupMachine;
   if (!staticBots) {
     intentsMachine = IntentsMachineFactory.getMachine(bot, botId, projectId, log);
     backupMachine = IntentsMachineFactory.getBackupMachine(bot, botId, projectId, log);
-    if (log) {console.log("Created backupMachine:", backupMachine);}
+    winston.debug("(tybotRoute) Created backupMachine:", backupMachine)
   }
   else {
     intentsMachine = {}
   }
 
-  // let intentsMachine;
-  // if (!staticBots) {
-  //   if (log) {console.log("intentsMachine to MongoDB");}
-  //   intentsMachine = new MongodbIntentsMachine({projectId: projectId, language: bot.language, log});
-  //   if (bot.intentsEngine === "tiledesk-ai") {
-  //     if (log) {console.log("intentsMachine to tiledesk-ai");}
-  //     intentsMachine = new TiledeskIntentsMachine(
-  //       {
-  //         //projectId: projectId,
-  //         //language: bot.language,
-  //         botId: botId
-  //         //TILEBOT_AI_ENDPOINT: process.env.TILEBOT_AI_ENDPOINT
-  //       });
-  //   }
-  // }
-  // else {
-  //   intentsMachine = {}
-  // }
-  //const intentsMachine = new TiledeskIntentsMachine({API_ENDPOINT: "https://MockIntentsMachine.tiledesk.repl.co", log: true});
-  // console.log("the bot is:", bot)
   const chatbot = new TiledeskChatbot({
     botsDataSource: botsDS,
     intentsFinder: intentsMachine,
@@ -189,11 +143,8 @@ router.post('/ext/:botid', async (req, res) => {
     MAX_EXECUTION_TIME: MAX_EXECUTION_TIME,
     log: log
   });
-  if (log) {console.log("MESSAGE CONTAINS:", message.text);}
-  // if (message.text === "\\\\start") { // patch for the misleading \\start training phrase
-  //   if (log) {console.log("forced conversion of \\\\start /start");}
-  //   message.text = "/start";
-  // }
+  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);
@@ -204,23 +155,19 @@ router.post('/ext/:botid', async (req, res) => {
     reply = await chatbot.replyToMessage(message);
   }
   catch(err) {
-    console.error("(tybotRoute) An error occurred replying to message:", JSON.stringify(message), "\nError:", err );
+    winston.error("(tybotRoute) An error occurred replying to message: ", err);
     return;
   }
   if (!reply) {
-    if (log) { console.log("(tybotRoute) No reply. Stop flow.") }
+    winston.verbose("(tybotRoute) No reply. Stop flow.")
     return;
   }
   
-  // console.log("reply is:", reply);
-  // if (reply.attributes.intent_info.intent_id) {
-  //   process.exit(1)
-  // }
   if (reply.actions && reply.actions.length > 0) { // structured actions (coming from chatbot designer)
     try {
-      if (log) {console.log("the actions:", JSON.stringify(reply.actions));}
+      winston.debug("(tybotRoute) Reply actions: ", reply.actions)
       let directives = TiledeskChatbotUtil.actionsToDirectives(reply.actions);
-      if (log) {console.log("the directives:", JSON.stringify(directives));}
+      winston.debug("(tybotRoute) the directives:", directives)
       let directivesPlug = new DirectivesChatbotPlug(
         {
           message: message,
@@ -237,15 +184,15 @@ router.post('/ext/:botid', async (req, res) => {
         }
       );
       directivesPlug.processDirectives( () => {
-        if (log) {console.log("Actions - Directives executed.");}
+        winston.verbose("(tybotRoute) Actions - Directives executed.");
       });
     }
     catch (error) {
-      console.error("Error while processing actions:", error);
+      winston.error("(tybotRoute) Error while processing actions:", error);
     }
   }
   else { // text answer (parse text directives to get actions)
-    if (log) {console.log("an answer:", reply.text);}
+    winston.verbose("(tybotRoute) No actions. Reply text: ", reply.text)
     reply.triggeredByMessageId = messageId;
     if (!reply.attributes) {
       reply.attributes = {}
@@ -260,9 +207,7 @@ router.post('/ext/:botid', async (req, res) => {
       log: false
     });
     apiext.sendSupportMessageExt(reply, projectId, requestId, token, () => {
-      if (log) {
-        //console.log("SupportMessageExt() reply sent:", JSON.stringify(reply));
-      }
+      winston.verbose("(tybotRoute) sendSupportMessageExt reply sent: ", reply)
     });
   }
   
@@ -273,13 +218,15 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
   const projectId = req.params.projectId;
   const requestId = req.params.requestId;
   const token = req.headers["authorization"];
-  if (log) {console.log("/ext projectId:", projectId);}
-  if (log) {console.log("/ext requestId:", requestId);}
-  if (log) {console.log("/ext req.headers:", req.headers);}
-  if (log) {console.log("/ext token:", token);}
+
+  winston.verbose("(tybotRoute) POST /ext/:projectId/requests/:requestId/messages called: " + requestId)
+  winston.debug("(tybotRoute) projectId " + projectId)
+  winston.debug("(tybotRoute) token " + token)
+  winston.debug("(tybotRoute) req.headers " + req.headers)
+  winston.debug("(tybotRoute) projectId " + projectId)
   
   let answer = req.body;
-  if (log) {console.log("/ext => answer on sendSupportMessageExt:", JSON.stringify(answer));}
+  winston.verbose("(tybotRoute) answer on sendSupportMessageExt: ", answer);
   const tdclient = new TiledeskClient({
     projectId: projectId,
     token: token,
@@ -287,81 +234,57 @@ router.post('/ext/:projectId/requests/:requestId/messages', async (req, res) =>
     APIKEY: "___",
     log: false
   });
+
   let request;
-  // const request_key = "tilebot:" + requestId;
-  // if (log) {console.log("request_key:", request_key);}
-  // if (tdcache) {
-  //   request = await tdcache.getJSON(request_key)
-  //   if (log) {console.log("Request from cache:", JSON.stringify(request));}
-  //   if (!request) {
-  //     if (log) {console.log("!Request from cache", requestId);}
-  //     try {
-  //       request = await tdclient.getRequestById(requestId);
-  //     }
-  //     catch(err) {
-  //       console.error("Error getting the request:", err)
-  //     }
-  //     if (log) {console.log("Got request with APIs (after no cache hit)");}
-  //   }
-  // }
-  // else {
-    // if (log) {console.log("No tdcache. Getting request with APIs", requestId);}
   try {
     request = await tdclient.getRequestById(requestId);
-    // console.log("Cache request found.");
   }
   catch(err) {
-    console.error("/ext => Request not found:", requestId);
+    winston.error("(tybotRoute) request not found with id " +  requestId);
   }
-    // if (log) {console.log("(No tdcache) Got request with APIs");}
-  // }
+
   if (!request) {
-    if (log) {console.log("/ext => Creating new Request. Chatbot-pure directives still work. Tiledesk specific directives don't");}
+    winston.verbose("(tybotRoute) Creating new Request. Chatbot-pure directives still work. Tiledesk specific directives don't")
     const request_botId_key = "tilebot:botId_requests:" + requestId;
     const botId = await tdcache.get(request_botId_key);
-    if (log) {console.log("/ext => current botId [" + request_botId_key + "]:", botId);}
+    winston.verbose("(tybotRoute) current botId [" + request_botId_key + "]:" + botId)
     request = {
       request_id: requestId,
       id_project: projectId,
       bot_id: botId
     }
   }
-  if (log) {
-    console.log("/ext request....", JSON.stringify(request));
-    console.log("/ext API_ENDPOINT....", API_ENDPOINT);
-    console.log("/ext process.env.TILEBOT_ENDPOINT....", TILEBOT_ENDPOINT);
-  }
+  winston.debug("(tybotRoute) request: ", request);
+  winston.debug("(tybotRoute) API_ENDPOINT: " + API_ENDPOINT);
+  winston.debug("(tybotRoute) request: " + TILEBOT_ENDPOINT);
+
   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));}
+
   const original_answer_text = answer.text;
   const bot_answer = await ExtUtil.execPipelineExt(request, answer, directivesPlug, tdcache, log);
-  if (log) {console.log("/ext => bot_answer", JSON.stringify(bot_answer))}
+  winston.debug("(tybotRoute) bot_answer: ", bot_answer);
+
   if (bot_answer) {
-    if (log) {console.log("/ext => adding to bot_answer original_answer_text:", JSON.stringify(original_answer_text));}
+    winston.debug("(tybotRoute) adding to bot_answer original_answer_text: ", original_answer_text);
     if (!bot_answer.attributes) {
       bot_answer.attributes = {};
     }
-    // if (!bot_answer.text) {
-    //   bot_answer.text = "..."
-    // }
+    
     bot_answer.attributes["_raw_message"] = original_answer_text;
-    // if (log) {console.log("bot_answer", JSON.stringify(bot_answer));}
     tdclient.sendSupportMessage(requestId, bot_answer, (err, response) => {
-      if (log) {console.log("/ext => bot_answer sent:", JSON.stringify(bot_answer));}
+      winston.verbose("(tybotRoute) Bot answer sent")
       if (err) {
-        console.error("/ext => Error sending message", JSON.stringify(err));
+        winston.error("(tybotRoute) Error sending message", err);
       }
-      directivesPlug.processDirectives( () => {
-        if (log) {console.log("After message - Directives executed.");}
+      directivesPlug.processDirectives(() => {
+        winston.verbose("(tybotRoute) Directives executed")
       });
     });
   }
   else {
-    if (log) {console.log("/ext => !bot_answer");}
-    directivesPlug.processDirectives( () => {
-      if (log) {console.log("Directives executed.");}
+    winston.verbose("(tybotRoute) No bot_answer")
+    directivesPlug.processDirectives(() => {
+      winston.verbose("(tybotRoute) Directives executed")
     });
   }
   
@@ -391,73 +314,12 @@ router.get('/ext/reserved/parameters/requests/:requestid', async (req, res) => {
     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) {
@@ -467,14 +329,13 @@ router.get('/ext/parameters/requests/:requestid', async (req, res) => {
   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");
+  else if (!request_parts || (request_parts && request_parts.length < 4) ) {
+    res.status(500).send("Invalid request id " + requestId);
     return;
   }
   const parameters = await TiledeskChatbot.allParametersStatic(tdcache, requestId);
@@ -486,45 +347,7 @@ router.get('/ext/parameters/requests/:requestid', async (req, res) => {
     res.send(parameters);
   }
   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,
-      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,
-      "lastUserImageURL", // image
-      "lastUserImageName", // image
-      "lastUserImageWidth", // image
-      "lastUserImageHeight", // image
-      "lastUserImageType", // image
-      "lastUserDocumentURL", // file
-      "lastUserDocumentName", // file
-      "lastUserDocumentType" // file
-    ]
-    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);
   }
 });
@@ -538,7 +361,8 @@ router.get('/test/webrequest/get/plain/:username', async (req, res) => {
 });
 
 router.post('/test/webrequest/post/plain', async (req, res) => {
-  console.log("/post/plain req.body:", req.body);
+  winston.verbose("(tybotRoute) POST /test/webrequest/post/plain called");
+  winston.debug("(tybotRoute) POST /test/webrequest/post/plain req.body:", req.body);
   if (req && req.body && req.body.name) {
     res.send("Your name is " + req.body.name);
   }
@@ -548,16 +372,14 @@ router.post('/test/webrequest/post/plain', async (req, res) => {
 });
 
 router.post('/echobot', (req, res) => {
-  //console.log('echobot message body.payload: ', JSON.stringify(req.body.payload));
+  winston.verbose("(tybotRoute) POST /echobot called");
+  winston.debug("(tybotRoute) POST /echobot req.body: ", req.body.payload);
+
   const message = req.body.payload;
   const token = req.body.token;
   const requestId = message.request.request_id;
   const projectId = message.id_project;
 
-  // console.log("/echobot projectId:", projectId);
-  // console.log("/echobot requestId:", requestId);
-  // console.log("/echobot token:", token);
-  
   const tdclient = new TiledeskClient({
     projectId: projectId,
     token: token,
@@ -574,10 +396,7 @@ router.post('/echobot', (req, res) => {
   }
   tdclient.sendSupportMessage(requestId, msg, (err, response) => {
     if (err) {
-      console.error("Error sending message:"); //, err);
-    }
-    else {
-      //console.log("message sent.");
+      winston.error("(tybotRoute) Error sending message"); //, err);
     }
   });
 });
@@ -588,6 +407,10 @@ router.post('/block/:project_id/:bot_id/:block_id', async (req, res) => {
   const bot_id = req.params.bot_id;
   const block_id = req.params.block_id;
   const body = req.body;
+
+  winston.verbose("(tybotRoute) POST /block/:project_id/:bot_id/:block_id called");
+  winston.debug("(tybotRoute) POST /block/:project_id/:bot_id/:block_id req.body: ", body);
+
   const async = body.async;
   const token = body.token;
   delete body.async;
@@ -614,88 +437,49 @@ router.post('/block/:project_id/:bot_id/:block_id', async (req, res) => {
   }
 
   if (async) {
-    console.log("Async webhook");
-    sendMessageToBot(TILEBOT_ENDPOINT, message, bot_id, (err, resbody) => {
+    winston.verbose("Async webhook");
+    tilebotService.sendMessageToBot(message, bot_id, (err, resbody) => {
       if (err) {
-        console.error("Async err:\n", err);
+        winston.error("Async webhook err:\n", err);
         return res.status(500).send({ success: false, error: err });
       }
       return res.status(200).send({ success: true });
     })
   } else {
     
-    console.log("Sync webhook. Subscribe and await for reply...")
+    winston.verbose("Sync webhook. Subscribe and await for reply...")
     const topic = `/webhooks/${request_id}`;
     
     try {
 
       const listener = async (message, topic) => {
-        console.log("Web response is: ", message, "for topic", topic);
+        winston.debug("Web response is: " + JSON.stringify(message) + " for topic " + topic);
         await tdcache.unsubscribe(topic, listener);
 
         let json = JSON.parse(message);
         let status = json.status ? json.status : 200;
-        console.log("Web response status: ", status);
+        winston.debug("Web response status: " + status);
 
         return res.status(status).send(json.payload);
       }
       await tdcache.subscribe(topic, listener);
 
     } catch(err) {
-      console.error("Error cache subscribe ", err);
+      winston.error("Error cache subscribe ", err);
       return res.status(500).send({ success: false, error: "Error during cache subscription"})
     }
 
-    sendMessageToBot(TILEBOT_ENDPOINT, message, bot_id, () => {
-      console.log("Sync webhook message sent: ", message);
+    tilebotService.sendMessageToBot(message, bot_id, () => {
+      winston.debug("Sync webhook message sent: ", message);
     })
   }
 
 });
 
-// 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);
+  winston.info("(Tilebot) Starting Tilebot..")
+
   if (settings.bots) { // static bots data source
     staticBots = settings.bots;
   }
@@ -710,7 +494,7 @@ async function startApp(settings, completionCallback) {
   }
   else {
     API_ENDPOINT = settings.API_ENDPOINT;
-    console.log("(Tilebot) settings.API_ENDPOINT:", API_ENDPOINT);
+    winston.info("(Tilebot) settings.API_ENDPOINT:" + API_ENDPOINT);
   }
 
   if (!settings.TILEBOT_ENDPOINT) {
@@ -719,8 +503,7 @@ async function startApp(settings, completionCallback) {
   else {
     TILEBOT_ENDPOINT = settings.TILEBOT_ENDPOINT
   }
-  console.log("(Tilebot) settings.TILEBOT_ENDPOINT:", TILEBOT_ENDPOINT);
-
+  winston.info("(Tilebot) settings.TILEBOT_ENDPOINT:" + TILEBOT_ENDPOINT);
 
   if (settings.REDIS_HOST && settings.REDIS_PORT) {
     tdcache = new TdCache({
@@ -736,8 +519,7 @@ async function startApp(settings, completionCallback) {
   else {
     log = true;
   }
-  console.log("(Tilebot) log:", log);
-
+  winston.info("(Tilebot) Log: " + log);
 
   if (process.env.CHATBOT_MAX_STEPS) {
     MAX_STEPS = Number(process.env.CHATBOT_MAX_STEPS);
@@ -747,49 +529,34 @@ async function startApp(settings, completionCallback) {
     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)
-
+  winston.info("(Tilebot) MAX_STEPS: " + MAX_STEPS);
+  winston.info("(Tilebot) MAX_EXECUTION_TIME: " + MAX_EXECUTION_TIME);
+  
   var pjson = require('./package.json');
-  console.log("(Tilebot) Starting Tilebot connector v" + pjson.version);
+  winston.info("(Tilebot) Starting Tilebot connector v" + pjson.version);
 
   if (!staticBots) {
-    console.log("(Tilebot) Connecting to mongodb...");
+    winston.info("(Tilebot) Connecting to MongoDB...");
     // connection = 
     mongoose.connect(settings.MONGODB_URI, { "useNewUrlParser": true, "autoIndex": false }, async (err) => {
       if (err) { 
-        console.error('(Tilebot) Failed to connect to MongoDB on ' + settings.MONGODB_URI + " ", err);
+        winston.error('(Tilebot) Failed to connect to MongoDB on ' + settings.MONGODB_URI + " ", err);
       }
       else {
-        console.log("(Tilebot) mongodb connection ok.");
+        winston.info("(Tilebot) MongoDB Connected");
         await connectRedis();
-        console.info("Tilebot started.");
+        winston.info("(Tilebot) Tilebot started");
+
         if (completionCallback) {
           completionCallback();
         }
-        // if (tdcache) {
-        //   try {
-        //     console.log("(Tilebot) Connecting Redis...");
-        //     await tdcache.connect();
-        //   }
-        //   catch (error) {
-        //     tdcache = null;
-        //     console.error("(Tilebot) Redis connection error:", error);
-        //     process.exit(1);
-        //   }
-        //   console.log("(Tilebot) Redis connected.");
-        // }
-        // console.info("Tilebot started.");
-        // if (completionCallback) {
-        //   completionCallback();
-        // }
       }
     });
   }
   else {
-    console.log("(Tilebot) Using static bots.");
+    winston.info("(Tilebot) Using static bots");
     await connectRedis();
-    console.info("Tilebot started.");
+    winston.info("(Tilebot) Tilebot started");
     if (completionCallback) {
       completionCallback();
     }
@@ -799,15 +566,15 @@ async function startApp(settings, completionCallback) {
 async function connectRedis() {
   if (tdcache) {
     try {
-      console.log("(Tilebot) Connecting Redis...");
+      winston.info("(Tilebot) Connecting Redis...");
       await tdcache.connect();
     }
     catch (error) {
       tdcache = null;
-      console.error("(Tilebot) Redis connection error:", error);
+      winston.error("(Tilebot) Redis connection error: ", error);
       process.exit(1);
     }
-    console.log("(Tilebot) Redis connected.");
+    winston.info("(Tilebot) Redis connected");
   }
   return;
 }
@@ -831,47 +598,10 @@ 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 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));
-  }
+  winston.verbose("(tybotRoute) myrequest API URL:" + options.url);
+  winston.debug("(tybotRoute) myrequest Options:", options);
+
   axios(
     {
       url: options.url,
@@ -881,11 +611,8 @@ function myrequest(options, callback, log) {
       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);
-      }
+      winston.verbose("Response for url:" + options.url);
+      winston.debug("Response headers:\n", res.headers);
       if (res && res.status == 200 && res.data) {
         if (callback) {
           callback(null, res.data);
@@ -896,9 +623,8 @@ function myrequest(options, callback, log) {
           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);
+    }).catch((error) => {
+      winston.error("(tybotRoute index) An error occurred: ", error);
       if (callback) {
         callback(error, null, null);
       }