@tiledesk/tiledesk-voice-twilio-connector 0.1.2

package/index.js

@@ -0,0 +1,1029 @@
+"use strict";
+const express = require("express");
+const bodyParser = require("body-parser")
+const router = express.Router();
+const winston = require("./winston");
+const fs = require("fs");
+const path = require('path');
+const pjson = require('./package.json');
+const axios = require("axios").default;
+
+
+router.use(bodyParser.json()); // support json encoded bodies
+router.use(express.urlencoded({ extended: true })); // support encoded bodies
+router.use(express.static(path.join(__dirname, 'template')));
+
+//template
+const manageApp = require('./routes/manageApp');
+const manageRoute = manageApp.router;
+router.use('/manage', manageRoute);
+
+// tiledesk clients
+const { TiledeskChannel } = require("./tiledesk/TiledeskChannel");
+const { TiledeskTwilioTranslator } = require('./tiledesk/TiledeskTwilioTranslator');
+
+//voice clients
+const { VoiceChannel } = require("./tiledesk/VoiceChannel");
+let voiceChannel = null;
+
+// mongo
+const { KVBaseMongo } = require('./tiledesk/KVBaseMongo');
+const kvbase_collection = 'kvstore';
+const db = new KVBaseMongo(kvbase_collection);
+
+// redis
+var redis = require('redis')
+var redis_client;
+
+//UTILS
+const utils_message = require('./tiledesk/utils-message.js')
+const CHANNEL_NAME = require('./tiledesk/constants').CHANNEL_NAME
+const TYPE_MESSAGE = require('./tiledesk/constants').TYPE_MESSAGE
+const CALL_STATUS = require('./tiledesk/constants').CALL_STATUS
+const utils = require('./tiledesk/utils.js')
+
+let API_URL = null;
+let BASE_URL = null;
+let REDIS_HOST = null;
+let REDIS_PORT = null;
+let REDIS_PASSWORD = null;
+let BRAND_NAME = null;
+
+let twilio = require('twilio');
+const VoiceResponse = require('twilio').twiml.VoiceResponse;
+const { MessagingResponse } = require('twilio').twiml;
+
+router.get("/", async (req, res) => {
+  res.send("Welcome to Tiledesk-voice-twilio connector");
+});
+
+
+// TILEDESK WEBHOOK: message from tiledesk to user (chatbot/agent messagges)
+router.post("/tiledesk", async (req, res) => {
+  let tiledeskMessage = req.body.payload
+  let project_id = tiledeskMessage.id_project
+  
+  //const CONTENT_KEY = "vxml-" + project_id;
+  //let settings = await db.get(CONTENT_KEY)
+  
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  });
+  tdChannel.setProjectId(project_id)
+  
+  await tdChannel.addMessageToQueue(tiledeskMessage)
+  
+  res.send("(vxml) Message received from Voice VXML Proxy");
+
+  
+});
+
+// TWILIO WEBHOOK : message from user to tiledesk
+router.post('/webhook/:id_project', async (req, res) => {
+  winston.debug('(voice) called POST /webhook/:id_project ', req.params)
+  
+  let project_id = req.params.id_project;
+  let callSid = req.body.CallSid;
+  let from = req.body.From;
+  let to = req.body.To;
+  
+  if(!from || !to){
+     return res.status(404).send({error: "Error: Missing from/to parameters"})
+  }
+  from = utils.getNumber(from); //remove '+' from number
+  to = utils.getNumber(to); //remove '+' from number
+  
+  const CONTENT_KEY = CHANNEL_NAME + "-" + project_id;
+  let settings = await db.get(CONTENT_KEY);
+  if(!settings){
+    return res.status(404).send({error: "VOICE Channel not already connected"})
+  }
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid
+  };
+  
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client,
+  });
+  tdChannel.setProjectId(project_id)
+  
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  let user = await tdChannel.signIn(from, settings);
+  if(!user){
+    res.status(401).send({message: "Cannot able to signIn with current caller phone :" + from});
+    return;
+  }
+  
+  //let conversation_id = await tdChannel.getConversation(ani, callId, user.token);
+  let conversation_id = await tdChannel.generateConversation(from, callSid, user.token);
+  winston.debug("(voice) conversation returned:"+ conversation_id);
+  
+  //save data to redis
+  let session_data = {
+    from: from,
+    to: to,
+    callSid: callSid,
+    project_id: project_id,
+    user: user,
+    conversation_id: conversation_id
+  }
+  if (!redis_client) {
+    return res.status(500).send({ message: "Redis not ready. Check redis connection..." })
+  }
+  //for (const [key, value] of Object.entries(redis_data)){
+  //  await redis_client.hSet('tiledesk:vxml:'+callId, key, JSON.stringify(value))
+  //}
+  //await redis_client.expire('tiledesk:vxml:'+callId, 86400)
+  
+  await redis_client.set('tiledesk:vxml:'+callSid+':session', JSON.stringify(session_data), {'EX': 86400});
+  
+  
+  let tiledeskMessage= {
+    text:'/start',
+    senderFullname: from,
+    type: 'text',
+    attributes: {
+      subtype: 'info',
+      payload: {
+        ... req.query //send all attributes back to chatbot
+      }
+    },
+    channel: { name: CHANNEL_NAME }
+  };
+  
+  let message = await tdChannel.send(tiledeskMessage, user.token, conversation_id)
+  if(!message){
+    return res.status(503).send({ message: "Bad response: Quota exceeded" })
+  }
+  
+  
+  //generate Tiledesk wait message
+  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+  let waitTiledeskMessage = await tdChannel.generateWaitTdMessage(from, delayTime)
+  //update delayIndex for wait command message time
+  await voiceChannel.saveDelayIndexForCallId(from)
+  
+  // send standard wait vxml message
+  let messageToVXML = await tdTranslator.toVXML(waitTiledeskMessage, callSid, vxmlAttributes) 
+  winston.debug('(voice) messageVXML-->'+ messageToVXML)
+  
+
+  // Render the response as XML in reply to the webhook request
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send(messageToVXML);
+  
+});
+
+
+router.post('/nextblock/:callSid/', async(req, res) => {
+  winston.info("(vxml) called POST /nextblock" , req.body);
+  winston.info("(vxml) called POST /nextblock query", req.query);
+  
+  let usertext = req.body.SpeechResult;
+  let confidence = req.body.Confidence
+  let callSid = req.params.callSid;
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+
+  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  //let redis_data = await redis_client.hGetAll('tiledesk:vxml:'+callId);
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid,
+  };
+      
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id);
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  
+  //manage SPEECH FORM with <record>
+  
+  //se coda vuota (esiste)
+      //manda vxml wait
+  //se usertext vuoto e coda ha almeno un elemento
+      // genera vxml su quel messaggio
+  //se usertet non vuoto e coda non esiste 
+      //crea coda e manda messaggio su conversazione
+  
+  let message = {}, queue = []
+  queue = await tdChannel.getMessagesFromQueue(conversation_id)
+  winston.debug('/NEXT controllo coda--> ', queue.length, usertext)
+  if(queue.length === 0 && (usertext === '' || !usertext)){
+    winston.debug('QUEUE is empty--> ',queue)
+    
+    //CASE: queue is empty --> generate Tiledesk wait message and manage delayTime 
+    let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+    message = await tdChannel.generateWaitTdMessage(from, delayTime)
+    //update delayIndex for wait command message time
+    await voiceChannel.saveDelayIndexForCallId(from)
+    
+  } else if(queue.length > 0 && (usertext === '' || !usertext)){
+    
+    //CASE: queue has at least one message to reproduce --> get message from tiledesk queue and reset delayTime
+    message = queue[0]
+    winston.debug('QUEUE --> ',queue[0])
+    //remove message from queue
+    await tdChannel.removeMessageFromQueue(conversation_id, message._id)
+    //reset delayIndex for wait command message time
+    await voiceChannel.clearDelayTimeForCallId(callSid)
+    
+    queue = await tdChannel.getMessagesFromQueue(conversation_id)
+    winston.debug('QUEUE after remove --> ',queue.length)
+  }else{
+    //CASE:usertext is not empty and queue is empty -->  send message to tiledesk and manage delayTime 
+    let tiledeskMessage= {
+      text:usertext,
+      senderFullname: from,
+      type: 'text',
+      channel: { name: CHANNEL_NAME }
+    };
+    let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+    winston.debug("message sent : ", tdMessage);
+    //generate Tiledesk wait message
+    let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+    message = await tdChannel.generateWaitTdMessage(from, delayTime)
+    //update delayIndex for wait command message time
+    await voiceChannel.saveDelayIndexForCallId(callSid)
+  }
+  
+  /*
+  if(usertext === '' || !usertext){
+    //get message from queue
+    queue = await tdChannel.getMessagesFromQueue(conversation_id)
+    winston.debug('QUEUE --> ',queue.length)
+    if(queue.length === 0){
+      //CASE: queue is empty --> generate Tiledesk wait message
+      message = await tdChannel.generateWaitTdMessage(ani, callId)
+      winston.debug('QUEUE is empty--> ',queue)
+    }else{
+      //CASE: queue has at least one message to reproduce --> get message from tiledesk queue
+      message = queue[0]
+      winston.debug('QUEUE --> ',queue[0])
+      //remove message from queue
+      await tdChannel.removeMessageFromQueue(conversation_id, message._id)
+      
+      queue = await tdChannel.getMessagesFromQueue(conversation_id)
+      winston.debug('QUEUE after remove --> ',queue.length)
+    }
+  }else{
+    //send message to tiledesk 
+    let tiledeskMessage= {
+      text:usertext,
+      senderFullname: ani,
+      type: 'text',
+      channel: { name: CHANNEL_NAME }
+    };
+    let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+    winston.debug("message sent : ", tdMessage);
+    //generate Tiledesk wait message
+    message = await tdChannel.generateWaitTdMessage(ani, callId)
+  }
+  */
+  
+  // convert response to vxml
+  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes)
+  winston.debug("(vxml) VXML to SEND: "+ messageToVXML);
+  
+  // Render the response as XML in reply to the webhook request
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send(messageToVXML);
+})
+
+
+router.post('/menublock/:callSid', async (req, res) => {
+  winston.info("(voice) called POST /menu", req.body);
+  winston.info("(voice) called POST /menu query" , req.query);
+  
+  let message_text = '';
+  let attributes = {};
+  let button = {}
+  
+  let callSid = req.params.callSid;
+  let buttons_menu = req.query.menu_options;
+  let buttonNoMatch = req.query.button_action;
+  let previousIntentName = req.query.intentName;
+  
+  let menu_choice = req.body.Digits || '';
+  
+  /** use case: DTMF MENU **/
+  if(buttons_menu){
+    buttons_menu.split(';').some((option)=> {
+      option = option.split(':')
+      if(option[0] === menu_choice){
+        button.value = option[0]
+        button.action = '#' + option[1]
+        return true;
+      }
+    })
+    
+    
+    /* case noMatch input: Digits is not in a valid menu option*/
+    if(Object.keys(button).length === 0){
+        button.value = menu_choice
+        button.action = '#' + buttonNoMatch
+    }
+    
+    message_text = button.value.toString();
+    attributes = {
+      action: button.action
+    }
+    
+  }else{
+    /** use case: DTMF Speech **/
+    message_text = menu_choice.toString(); //.replace(/(\d)/g, '$1 '); //convert number to string and then add a space after each number
+  }
+  
+  winston.debug("(vxml) button menu: ", button);
+  winston.debug("(vxml) message_text menu: "+ message_text);
+  
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+
+  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid,
+  };
+
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id);
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  //send message to tiledesk 
+  let tiledeskMessage= {
+    text:message_text,
+    senderFullname: from,
+    type: 'text',
+    channel: { name: CHANNEL_NAME },
+    attributes: attributes
+  };
+  console.log('messssss', tiledeskMessage)
+  let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+
+  //generate Tiledesk wait message
+  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+  let message = await tdChannel.generateWaitTdMessage(from, delayTime)    
+  //update delayIndex for wait command message time
+  await voiceChannel.saveDelayIndexForCallId(callSid)
+
+  // convert response to vxml
+  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes)
+  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
+  
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send(messageToVXML);
+  
+});
+
+router.post('/handle/:callSid/:event', async (req, res) => {
+  winston.info("(voice) called POST /handle", req.body);
+  winston.info("(voice) called POST /handle query -->", req.query);
+  winston.info("(voice) called POST /handle params-->", req.params);
+  
+  let event = req.params.event;
+  let callSid = req.params.callSid;
+  let button_action = '#' + req.query.button_action;
+  let previousIntentName = req.query.intentName;
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+
+  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid,
+  };
+
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id);
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+
+  //send message to tiledesk 
+  let tiledeskMessage= {
+    text: "/" + event,
+    senderFullname: from,
+    type: 'text',
+    channel: { name: CHANNEL_NAME },
+    attributes: {
+      type: 'info',
+      action: button_action
+    }
+  };
+  let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+
+  //generate Tiledesk wait message
+  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+  let message = await tdChannel.generateWaitTdMessage(callSid, delayTime) 
+  ///update delayIndex for wait command message time
+  await voiceChannel.saveDelayIndexForCallId(callSid)
+
+  // convert response to vxml
+  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes)
+  winston.debug("(vxml) VXML to SEND: "+ messageToVXML);
+  
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send(messageToVXML);
+  
+});
+
+
+/* ----> catch Event block <----- */
+router.post('/event/:callSid/:event', async(req, res)=> {
+  winston.info("(voice) called POST /event" , req.params);
+  winston.debug("(voice) called POST /event query" , req.query);
+  winston.debug("(voice) called POST /event body" , req.body);
+  
+  let event = req.params.event;
+  let callSid = req.params.callSid;
+  let currentIntentName = req.query.intentName;
+  let currentIntentTimestamp  = req.query.previousIntentTimestamp;
+  
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+  
+  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid,
+  };
+
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id);
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  let button_action = ''
+  if(event === 'transfer'){
+    let callStatus = req.body.CallStatus;
+    switch(callStatus){
+      case CALL_STATUS.COMPLETED:
+        button_action = '#' + req.query.button_success;
+        break;
+      case CALL_STATUS.FAILED:
+        button_action = '#' + req.query.button_failure;
+        break;
+    }
+    
+    switch(callStatus){
+        case CALL_STATUS.COMPLETED:
+        case CALL_STATUS.FAILED: {
+          //send message to tiledesk 
+          let tiledeskMessage= {
+            //text:'\\close',
+            text:'/'+event,
+            senderFullname: from,
+            type: 'text',
+            channel: { name: CHANNEL_NAME },
+            attributes: {
+              subtype: "info",
+              action: button_action,
+              payload: {
+                event: event, 
+                lastBlock: currentIntentName, 
+                lastTimestamp: currentIntentTimestamp
+              }
+            }
+          };
+          let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+        }
+    }
+    
+  }
+  
+  
+  //generate Tiledesk wait message
+  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+  let message = await tdChannel.generateWaitTdMessage(callSid, delayTime) 
+  ///update delayIndex for wait command message time
+  await voiceChannel.saveDelayIndexForCallId(callSid)
+
+  // convert response to vxml
+  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes)
+  winston.debug("(vxml) VXML to SEND: "+ messageToVXML);
+  
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send(messageToVXML);
+})
+
+
+/* ----> catch Twilio Events <----- */
+router.post('/twilio/status',async (req, res) => {
+  winston.debug('+++++++++++(voice) called POST twilio/status ', req.body);
+  
+  let event = req.body.CallStatus;
+  let callSid = req.body.CallSid;
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+  
+  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid,
+  };
+  
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id)
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  
+  switch(event){
+    case CALL_STATUS.COMPLETED:{
+      //send message to tiledesk 
+      let tiledeskMessage= {
+        //text:'\\close',
+        text:'/close',
+        senderFullname: from,
+        type: 'text',
+        channel: { name: CHANNEL_NAME },
+        attributes: {
+          subtype: "info",
+          action: 'close'+JSON.stringify({event: event}),
+          payload: {
+            catchEvent: event
+          },
+          timestamp: 'xxxxxx'
+        }
+      };
+
+      let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+
+      //remove session data for current callId and relative queue data
+      await redis_client.del('tiledesk:vxml:'+callSid+':session');
+      await redis_client.del('tiledesk:vxml:'+callSid+':delayIndex');
+      await tdChannel.clearQueue(conversation_id);
+      break;
+    }
+  }
+  
+   res.status(200).send();
+
+})
+
+router.post('/twilio/fail',async (req, res) => {
+  winston.debug('+++++++++++(voice) called POST twilio/fail ', req.params)
+  winston.debug('+++++++++++(voice) called POST twilio/fail ', req.body)
+
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send('<Response></Response>');
+})
+
+
+/* ----> catch Twilio Events <----- */
+router.post('/record/:callSid/',async (req, res) => {
+  winston.debug('+++++++++++(voice) called POST record/:callSid ', req.body);
+  
+  let callSid = req.body.CallSid;
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+  
+  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid,
+  };
+  
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id)
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  
+  let audioFileUrl = req.body.RecordingUrl
+  let textMessage = await tdChannel.speechToText(audioFileUrl, 'whisper-1')
+  winston.debug('(voice) Message captured after STT -->', textMessage)
+  
+  if(!textMessage){
+    //case NO_INPUT
+    const queryString = utils.buildQueryString(req.query);
+    console.log('case no input.. redirect '+ queryString)
+    
+    return await axios({
+      url: "http://localhost:3000/handle/" + callSid + '/no_input'+ queryString,
+      headers: req.headers,
+      data: req.body,
+      method: 'POST'
+    }).then((response) => {
+      winston.debug("[TiledeskChannel] speechToText response : ", response.data);
+      return res.status(response.status).send(response.data);
+    }).catch((err) => {
+      winston.error("[TiledeskChannel] speechToText error: ", err);
+      return res.status(500).send({ success: false, message: "Errore while redirect to /handle for callSid " + callSid});;
+    })
+  }
+  
+  
+  let tiledeskMessage= {
+      text:textMessage,
+      senderFullname: from,
+      type: 'text',
+      channel: { name: CHANNEL_NAME }
+    };
+  let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+  winston.debug("message sent : ", tdMessage);
+  //generate Tiledesk wait message
+  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+  let message = await tdChannel.generateWaitTdMessage(from, delayTime)
+  //update delayIndex for wait command message time
+  await voiceChannel.saveDelayIndexForCallId(callSid)
+  
+  
+  
+  res.set('Content-Type', 'application/xml');
+  res.status(200).send(message);
+
+})
+
+
+/**   --> only for test purpose <--   **/
+router.get('/test', async (req, res) => {
+  winston.info("(vxml) called GET /test" , req.query);
+  
+  let project_id = req.query.id_project;
+  let callSid = req.body.CallSid;
+  let from = req.body.From;
+  let to = req.body.To;
+  
+  if(!from || !to){
+     return res.status(404).send({error: "Error: Missing from/to parameters"})
+  }
+  from = utils.getNumber(from); //remove '+' from number
+  to = utils.getNumber(to); //remove '+' from number
+  
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client,
+  });
+  tdChannel.setProjectId(project_id)
+  
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL
+  });
+  
+  //let result = await tdChannel.signIn(ani)
+  
+  //let conversation_id = await tdChannel.getConversation(ani, callId, result.token);
+  //let message = await tdChannel.sendMessageAndWait(ani, result.chat21.user_data, conversation_id, '/start');
+  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid);
+  let waitTiledeskMessage = await tdChannel.generateWaitTdMessage(from, delayTime);
+  
+  //console.log("response message: ", message);
+  let message2= {
+    attributes: {
+      commands: [
+        {
+          type: 'wait',
+          time: 500
+        },
+        {
+          type: 'message',
+          message: {
+            text: 'ciao',
+          }
+        }
+      ]
+    }
+  }
+  
+  let message_buttons = {
+    attributes: {
+      disableInputMessage: true,
+      commands: [
+        {
+          type: 'wait',
+          time: 500
+        },
+        {
+          type: 'message',
+          message: {
+            text: 'ciao',
+            type: 'text',
+            attributes: {
+              attachment: {
+                buttons: [
+                  {value: 'button1', type: 'action', target: 'blank', action: '#action1'},
+                  {value: 'button2', type: 'action', target: 'blank', action: '#action2'}
+                ]
+              }
+            }
+          }
+        },
+        {
+          type: 'wait',
+          time: 500
+        },
+        {
+          type: 'message',
+          message: {
+            text: 'ciao 2',
+            type: 'frame',
+            metadata: {
+              src:"https://your-audio-url.com"
+            }
+          }
+        },
+        {
+          type: 'wait',
+          time: 0
+        },
+        /*{
+          type: 'settings',
+          subType: 'blind_transfer',
+          settings: {
+            transferTo: "6040",
+            transferType: "consultation",
+            falseIntent: "#falseIntenttt",
+            trueIntent: "#trueIntennt"
+          }
+        }*/
+        /*{
+          type: 'settings',
+          subType: 'dtmf_form',
+          settings: {
+            minDigits: 5,
+            maxDigits: 5,
+            terminators: "#"
+          }
+        }*/
+        {
+          type: 'settings',
+          subType: 'speech_form',
+          settings: {
+            noInputIntent: "#a",
+            noInputTimeout: 2000,
+            incompleteSpeechTimeout: 2000
+          }
+        }
+      ]
+    }
+  }
+
+  
+  let vxmlAttributes = {
+    voiceName: "Polly.Bianca",
+    voiceLanguage: "it-IT",
+    callSid: callSid
+  };
+  
+  
+  
+  // convert response to vxml
+  let messageToVXML = await tdTranslator.toVXML(message_buttons, callSid, vxmlAttributes)
+  //let disconnect = await tdChannel.disconnect();
+  
+  
+  res.set('Content-Type', 'text/xml');
+  res.status(200).send(messageToVXML);
+  
+  //res.status(200).send(message);
+  
+})
+
+
+async function connectRedis() {
+  /*redis_client = await redis.createClient({
+    host: REDIS_HOST,
+    port: REDIS_PORT,
+    password: REDIS_PASSWORD
+  });*/
+  
+  if(REDIS_PASSWORD){
+    redis_client = await redis.createClient({
+      socket: {
+        host: REDIS_HOST,
+        port: REDIS_PORT
+      },
+      password: REDIS_PASSWORD,
+    })
+  }else {
+    redis_client = await redis.createClient({
+      url: 'redis://'+REDIS_HOST+':'+REDIS_PORT
+    })
+  }
+  
+  
+  redis_client.on('error', err => {
+    winston.info('(voice) Connect Redis Error ' + err);
+  })
+  /*
+  redis_client.on('connect', () => {
+    winston.info('Redis Connected!'); // Connected!
+  });
+  */
+  redis_client.on('ready', () => {
+    winston.info("(voice) Redis ready!")
+  })
+  await redis_client.connect(); // only for v4
+  require('bluebird').promisifyAll(redis_client)
+
+}
+
+async function startApp(settings, callback) {
+  winston.info("(voice) Starting VOICE TWILIO App");
+  
+  if (!settings.MONGODB_URI) {
+    winston.error("(voice) MONGODB_URI is mandatory. Exit...");
+    return callback('Missing parameter: MONGODB_URI');
+  }
+  
+  if (!settings.API_URL) {
+    winston.error("(voice) API_URL is mandatory. Exit...");
+    return callback('Missing parameter: API_URL');
+  } else {
+    API_URL = settings.API_URL;
+    winston.info("(voice) API_URL: " + API_URL);
+  }
+  
+  if (!settings.BASE_URL) {
+    winston.error("(voice) BASE_URL is mandatory. Exit...");
+    return callback('Missing parameter: BASE_URL');
+  } else {
+    BASE_URL = settings.BASE_URL;
+    winston.info("(voice) BASE_URL: " + BASE_URL);
+  }
+  
+  if (settings.BRAND_NAME) {
+    BRAND_NAME = settings.BRAND_NAME
+  }
+  
+  if (settings.REDIS_HOST && settings.REDIS_PORT) {
+    REDIS_HOST = settings.REDIS_HOST;
+    REDIS_PORT = settings.REDIS_PORT;
+    REDIS_PASSWORD = settings.REDIS_PASSWORD;
+    await connectRedis();
+  } else {
+    winston.error("(voice) Missing redis parameters --> REDIS_HOST and REDIS_PORT");
+  }
+  
+  //init VOICE CHANNEL
+  voiceChannel = new VoiceChannel({
+    BASE_POOLING_DELAY: settings.BASE_POOLING_DELAY || 250,
+    redis_client: redis_client,
+  })
+  
+  if (settings.dbconnection) {
+    db.reuseConnection(settings.dbconnection, () => {
+      winston.info("(voice) KVBaseMongo reused exsisting db connection");
+      if (callback) {
+        callback(null);
+      }
+    })
+  } else {
+    db.connect(settings.MONGODB_URI, () => {
+      winston.info("(voice) KVBaseMongo successfully connected.");
+  
+      if (callback) {
+        callback(null);
+      }
+    });
+  }
+  
+  manageApp.startApp({
+    API_URL: API_URL,
+    BASE_URL: BASE_URL,
+    BRAND_NAME: BRAND_NAME,
+    DB: db,
+    redis_client: redis_client
+  }, (err) => {
+    if (!err) {
+      winston.info("Manage route succesfully started.");
+    } else {
+      winston.info("(voice) Unable to start API route.")
+    }
+  })
+  
+}
+
+function readHTMLFile(templateName, callback) {
+  fs.readFile(__dirname + '/template' + templateName, { encoding: 'utf-8' },
+    function(err, html) {
+      if (err) {
+        throw err;
+        //callback(err);
+      } else {
+        callback(null, html)
+      }
+    })
+}
+
+module.exports = { router: router, startApp: startApp };