@tiledesk/tiledesk-voice-twilio-connector 0.1.28 → 0.2.0-rc3

package/src/controllers/VoiceController.js

@@ -0,0 +1,488 @@
+/**
+ * VoiceController - Refactored Version
+ * 
+ * This controller handles HTTP requests/responses only.
+ * Business logic has been extracted to dedicated services:
+ * - SessionService: Session lifecycle management
+ * - MessageService: Queue polling and message retrieval
+ * - SpeechService: STT provider abstraction
+ * - TiledeskMessageBuilder: Message object factory
+ */
+
+const { TiledeskChannel } = require('../services/channels/TiledeskChannel');
+const { TiledeskTwilioTranslator } = require('../services/translators/TiledeskTwilioTranslator');
+const { SessionService } = require('../services/SessionService');
+const { MessageService } = require('../services/MessageService');
+const { SpeechService } = require('../services/SpeechService');
+const { TwilioService } = require('../services/TwilioService');
+const { TiledeskMessageBuilder } = require('../services/TiledeskMessageBuilder');
+const utilsMessage = require('../utils/utils-message');
+const utils = require('../utils/utils');
+const { TYPE_MESSAGE, CHANNEL_NAME, CALL_STATUS } = require('../utils/constants');
+const logger = require('../utils/logger');
+
+class VoiceController {
+    constructor(services) {
+        this.db = services.db;
+        this.config = services.config;
+
+        // Initialize channels
+        this.tdChannel = new TiledeskChannel({
+            API_URL: this.config.API_URL,
+            redis_client: services.redisClient
+        });
+
+        this.tdTranslator = new TiledeskTwilioTranslator({
+            BASE_URL: this.config.BASE_URL,
+            aiService: services.aiService,
+            uploadService: services.uploadService
+        });
+
+        // Initialize extracted services
+        this.sessionService = new SessionService({
+            voiceChannel: services.voiceChannel,
+            integrationService: services.integrationService,
+            tdChannel: this.tdChannel,
+            config: this.config
+        });
+
+        this.messageService = new MessageService({
+            voiceChannel: services.voiceChannel,
+            tdChannel: this.tdChannel,
+            config: this.config
+        });
+
+        this.speechService = new SpeechService({
+            aiService: services.aiService,
+            voiceChannel: services.voiceChannel
+        });
+
+        this.twilioService = new TwilioService({
+            db: this.db,
+            config: this.config
+        });
+    }
+
+    async index(req, res) {
+        res.send("Tiledesk Voice Connector");
+    }
+
+    async tiledesk(req, res) {
+        try {
+            const tiledeskMessage = req.body.payload;
+            const projectId = tiledeskMessage.id_project;
+
+            logger.debug(`(voice) Message received from Tiledesk in projectID: ${projectId} ---- text: ${tiledeskMessage.text}`);
+
+            if (!utilsMessage.messageType(TYPE_MESSAGE.INFO, tiledeskMessage) && !(tiledeskMessage.sender.indexOf(CHANNEL_NAME) > -1)) {
+                logger.debug(`> whook SAVE MESSAGE "${tiledeskMessage.text}" TO QUEUE at time ${new Date()}`);
+            }
+
+            if (await this.tdChannel.addMessageToQueue(tiledeskMessage)) {
+                await this._handlePlayRedirect(tiledeskMessage, projectId);
+            }
+
+            res.send("(voice) Message received from Voice Twilio Proxy");
+        } catch (error) {
+            logger.error("(voice) Error in tiledesk handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async _handlePlayRedirect(tiledeskMessage, projectId) {
+        const contentKey = `${CHANNEL_NAME}-${projectId}`;
+        await this.twilioService.handlePlayRedirect(
+            tiledeskMessage,
+            projectId,
+            contentKey,
+            this.tdTranslator.lastCallSidVerb
+        );
+    }
+
+    async webhook(req, res) {
+        try {
+            const startCall = Date.now();
+            logger.debug('(voice) called POST /webhook/:id_project ' + new Date(), req.params);
+
+            const projectId = req.params.id_project;
+            const callSid = req.body.CallSid;
+            let { From: from, To: to } = req.body;
+
+            // Validate inputs
+            if ((!from || !to) && from !== "client:Anonymous") {
+                return res.status(404).send({ error: "Error: Missing from/to parameters" });
+            }
+
+            from = utils.getNumber(from);
+            to = to ? utils.getNumber(to) : "client:AnonymousReceiver";
+
+            // Get project settings
+            const CONTENT_KEY = `${CHANNEL_NAME}-${projectId}`;
+            const settings = await this.db.get(CONTENT_KEY);
+            if (!settings) {
+                return res.status(404).send({ error: "VOICE Channel not already connected" });
+            }
+
+            // Sign in user
+            const user = await this.tdChannel.signIn(from, settings);
+            if (!user) {
+                return res.status(401).send({ message: `Cannot sign in with caller phone: ${from}` });
+            }
+
+            // Parallel initialization
+            const [conversationId, integrations] = await Promise.all([
+                this.tdChannel.generateConversation(from, callSid, projectId),
+                this.sessionService.getIntegrationKeys(projectId, settings.token)
+            ]);
+
+            logger.debug(`(voice) conversation returned: ${conversationId}`);
+
+            // Create session
+            const sessionData = await this.sessionService.createSession({
+                callSid,
+                from,
+                to,
+                projectId,
+                user,
+                conversationId,
+                integrations
+            });
+
+            // Send start message
+            const tiledeskMessage = TiledeskMessageBuilder.buildStartMessage(from, settings.department_id, req.body);
+            const response = await this.tdChannel.send(tiledeskMessage, user.token, conversationId, projectId);
+            if (!response) {
+                return res.status(503).send({ message: "Bad response: Quota exceeded" });
+            }
+
+            // Get response from queue
+            const message = await this.messageService.getNextMessage(callSid, conversationId, from);
+            const { vxmlAttributes } = await this.sessionService.getSessionContext(callSid);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionData);
+
+            logger.info(`Time to respond to /webhook/${projectId}: ${Date.now() - startCall}[ms]`);
+
+            res.set('Content-Type', 'text/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in webhook handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async nextblock(req, res) {
+        try {
+            const startCall = Date.now();
+            const callSid = req.params.callSid;
+            const userText = req.body.SpeechResult || req.body.Digits;
+            const bargein = req.query.bargein === 'true' || req.query.bargein === true;
+
+            logger.verbose(`(voice) called POST /nextblock at ${new Date()} with text: ${userText}, bargein: ${bargein}`);
+
+            const { vxmlAttributes, sessionInfo } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, project_id, user } = sessionInfo;
+
+            const message = await this._handleUserInput(userText, callSid, from, conversation_id, project_id, user, bargein);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+
+            logger.info(`Time to respond to /nextblock/${callSid}: ${Date.now() - startCall}[ms]`);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in nextblock handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async speechresult(req, res) {
+        try {
+            const startCall = Date.now();
+            const callSid = req.params.callSid;
+            const userText = req.body.SpeechResult;
+
+            logger.verbose(`(voice) called POST /speechresult at ${new Date()} with text: ${userText}`);
+
+            const { vxmlAttributes, sessionInfo } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, project_id, user } = sessionInfo;
+
+            const message = await this._handleUserInput(userText, callSid, from, conversation_id, project_id, user);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+
+            logger.info(`Time to respond to /speechresult/${callSid}: ${Date.now() - startCall}[ms]`);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in speechresult handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async _handleUserInput(userText, callSid, from, conversationId, projectId, user, bargein = false) {
+        if (!userText) {
+            return this.messageService.getNextMessage(callSid, conversationId, from);
+        }
+
+        // If barge-in is enabled and user has provided input, clear the queue
+        // This ensures we get the fresh response after user interruption
+        if (bargein) {
+            logger.debug(`[VoiceController] Barge-in detected, clearing queue for conversation: ${conversationId}`);
+            await this.tdChannel.clearQueue(conversationId);
+        }
+
+        const tiledeskMessage = TiledeskMessageBuilder.buildTextMessage(userText, from);
+        await this.tdChannel.send(tiledeskMessage, user.token, conversationId, projectId);
+
+        return this.messageService.getNextMessage(callSid, conversationId, from);
+    }
+
+    async recordAction(req, res) {
+        try {
+            const startCall = Date.now();
+            const callSid = req.body.CallSid;
+
+            logger.verbose(`(voice) called POST record/action/:callSid at time ${new Date()}`);
+
+            const { vxmlAttributes, sessionInfo } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, project_id } = sessionInfo;
+
+            const message = await this.messageService.getNextMessage(callSid, conversation_id, from);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+
+            logger.info(`Time to respond to /record/action/${callSid}: ${Date.now() - startCall}[ms]`);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in recordAction handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async recordCallback(req, res) {
+        try {
+            const startCall = Date.now();
+            const callSid = req.params.callSid || req.body.CallSid;
+            const audioFileUrl = req.body.RecordingUrl;
+            const buttonAction = req.query.button_action ? `#${req.query.button_action}` : '';
+            const previousIntentName = req.query.intentName || '';
+
+            logger.verbose(`(voice) called POST record/callback/:callSid at time ${new Date()}`);
+
+            const { sessionInfo, project_id } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, user } = sessionInfo;
+
+            // Get settings
+            const CONTENT_KEY = `${CHANNEL_NAME}-${project_id}`;
+            const settings = await this.db.get(CONTENT_KEY);
+            if (!settings) {
+                return res.status(404).send({ error: "VOICE Channel not already connected" });
+            }
+
+            // STT transcription
+            let tiledeskMessage = await this.speechService.transcribeAudio(audioFileUrl, callSid, sessionInfo, settings);
+
+            // Handle empty or no-input cases
+            if (!tiledeskMessage || !tiledeskMessage.text) {
+                tiledeskMessage = TiledeskMessageBuilder.buildNoInputMessage(from, buttonAction, {
+                    event: 'no_input',
+                    lastBlock: previousIntentName,
+                    lastTimestamp: Date.now()
+                });
+            } else {
+                const normalizedText = utils.normalizeSTT(tiledeskMessage.text);
+                if (!normalizedText) {
+                    tiledeskMessage = TiledeskMessageBuilder.buildNoInputMessage(from, buttonAction, {
+                        event: 'no_input',
+                        lastBlock: previousIntentName,
+                        lastTimestamp: Date.now()
+                    });
+                } else {
+                    tiledeskMessage.text = normalizedText;
+                }
+            }
+
+            await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+
+            logger.info(`Time to respond to /record/callback/${callSid}: ${Date.now() - startCall}[ms] with text ${tiledeskMessage.text}`);
+
+            res.status(200).send({ success: true, message: `Message sent to Tiledesk for callSid ${callSid}` });
+        } catch (error) {
+            logger.error("(voice) Error in recordCallback handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async menublock(req, res) {
+        try {
+            const startCall = Date.now();
+            const callSid = req.params.callSid;
+            const buttonsMenu = req.query.menu_options;
+            const buttonNoMatch = req.query.button_action;
+            const menuChoice = req.body.Digits || '';
+
+            logger.verbose(`/menublock at: ${new Date()} with text: ${menuChoice}`);
+
+            // Parse menu selection
+            const { messageText, attributes } = this._parseMenuSelection(menuChoice, buttonsMenu, buttonNoMatch);
+
+            const { vxmlAttributes, sessionInfo } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, project_id, user } = sessionInfo;
+
+            // Send selection to Tiledesk
+            const tiledeskMessage = TiledeskMessageBuilder.buildTextMessage(messageText, from, attributes);
+            const response = await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+            if (!response) {
+                return res.status(503).send({ message: "Bad response: Quota exceeded" });
+            }
+
+            const message = await this.messageService.getNextMessage(callSid, conversation_id, from);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+
+            logger.info(`Time to respond to /menublock/${callSid}: ${Date.now() - startCall}[ms]`);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in menublock handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    _parseMenuSelection(menuChoice, buttonsMenu, buttonNoMatch) {
+        if (!buttonsMenu) {
+            return { messageText: menuChoice.toString(), attributes: {} };
+        }
+
+        let button = {};
+        buttonsMenu.split(';').some((option) => {
+            const [value, action] = option.split(':');
+            if (value === menuChoice) {
+                button = { value, action: `#${action}` };
+                return true;
+            }
+        });
+
+        if (Object.keys(button).length === 0) {
+            button = { value: menuChoice, action: `#${buttonNoMatch}` };
+        }
+
+        return {
+            messageText: button.value.toString(),
+            attributes: { action: button.action }
+        };
+    }
+
+    async handleEvent(req, res) {
+        try {
+            const event = req.params.event;
+            const callSid = req.params.callSid;
+            const buttonAction = `#${req.query.button_action}`;
+            const previousIntentName = req.query.intentName;
+
+            logger.debug(`(voice) called POST /handle event: ${event}`);
+
+            const { vxmlAttributes, sessionInfo } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, project_id, user } = sessionInfo;
+
+            const tiledeskMessage = TiledeskMessageBuilder.buildEventMessage(event, from, {
+                action: buttonAction,
+                payload: { event, lastBlock: previousIntentName, lastTimestamp: Date.now() }
+            });
+            await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+
+            const message = await this.messageService.generateWaitMessage(callSid, from);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in handleEvent handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async event(req, res) {
+        try {
+            const event = req.params.event;
+            const callSid = req.params.callSid;
+            const currentIntentName = req.query.intentName;
+            const currentIntentTimestamp = req.query.previousIntentTimestamp;
+
+            logger.debug(`(voice) called POST /event: ${event}`);
+
+            const { vxmlAttributes, sessionInfo } = await this.sessionService.getSessionContext(callSid);
+            const { from, conversation_id, project_id, user } = sessionInfo;
+
+            if (event === 'transfer') {
+                await this._handleTransferEvent(req.body.CallStatus, from, conversation_id, project_id, user, {
+                    event,
+                    intentName: currentIntentName,
+                    timestamp: currentIntentTimestamp,
+                    buttonSuccess: req.query.button_success,
+                    buttonFailure: req.query.button_failure
+                });
+            }
+
+            const message = await this.messageService.generateWaitMessage(callSid, from);
+            const messageToVXML = await this.tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo);
+
+            res.set('Content-Type', 'application/xml');
+            res.status(200).send(messageToVXML);
+        } catch (error) {
+            logger.error("(voice) Error in event handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async _handleTransferEvent(callStatus, from, conversationId, projectId, user, options) {
+        const statusActions = {
+            [CALL_STATUS.COMPLETED]: `#${options.buttonSuccess}`,
+            [CALL_STATUS.FAILED]: `#${options.buttonFailure}`
+        };
+
+        const buttonAction = statusActions[callStatus];
+        if (!buttonAction) return;
+
+        const tiledeskMessage = TiledeskMessageBuilder.buildTransferMessage(from, options.event, {
+            action: buttonAction,
+            intentName: options.intentName,
+            timestamp: options.timestamp
+        });
+
+        await this.tdChannel.send(tiledeskMessage, user.token, conversationId, projectId);
+    }
+
+    async twilioStatus(req, res) {
+        try {
+            const event = req.body.CallStatus;
+            const callSid = req.body.CallSid;
+
+            logger.debug(`(voice) called POST twilio/status: ${event}`);
+
+            if (event === CALL_STATUS.COMPLETED) {
+                const { sessionInfo, conversation_id } = await this.sessionService.getSessionContext(callSid);
+                const { from, project_id, user } = sessionInfo;
+
+                const tiledeskMessage = TiledeskMessageBuilder.buildCloseMessage(from, event);
+                await this.tdChannel.send(tiledeskMessage, user.token, conversation_id, project_id);
+
+                await this.sessionService.cleanupSession(callSid, conversation_id);
+            }
+
+            res.status(200).send();
+        } catch (error) {
+            logger.error("(voice) Error in twilioStatus handler:", error);
+            res.status(500).send({ error: "Internal Server Error" });
+        }
+    }
+
+    async twilioFail(req, res) {
+        logger.debug('(voice) called POST twilio/fail', req.body);
+        res.set('Content-Type', 'application/xml');
+        res.status(200).send('<Response></Response>');
+    }
+}
+
+module.exports = VoiceController;