@hexabot-ai/api 3.0.0-alpha.3 → 3.1.1-alpha.0

package/dist/extensions/channels/web/base-web-channel.js

@@ -1,43 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -47,60 +14,40 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@nestjs/common");
 const event_emitter_1 = require("@nestjs/event-emitter");
-const body_parser_1 = __importDefault(require("body-parser"));
-const multer_1 = __importStar(require("multer"));
 const socket_io_1 = require("socket.io");
-const typeorm_1 = require("typeorm");
 const uuid_1 = require("uuid");
 const attachment_entity_1 = require("../../../attachment/entities/attachment.entity");
-const attachment_service_1 = require("../../../attachment/services/attachment.service");
 const types_1 = require("../../../attachment/types");
-const channel_service_1 = require("../../../channel/channel.service");
 const Handler_1 = __importDefault(require("../../../channel/lib/Handler"));
-const constants_1 = require("../../../chat/helpers/constants");
+const outbound_1 = require("../../../channel/lib/outbound");
+const channel_attachment_service_1 = require("../../../channel/services/channel-attachment.service");
 const message_service_1 = require("../../../chat/services/message.service");
 const subscriber_service_1 = require("../../../chat/services/subscriber.service");
+const thread_service_1 = require("../../../chat/services/thread.service");
 const button_1 = require("../../../chat/types/button");
 const message_1 = require("../../../chat/types/message");
-const content_entity_1 = require("../../../cms/entities/content.entity");
 const menu_service_1 = require("../../../cms/services/menu.service");
 const config_1 = require("../../../config");
-const i18n_service_1 = require("../../../i18n/services/i18n.service");
-const logger_service_1 = require("../../../logger/logger.service");
-const setting_service_1 = require("../../../setting/services/setting.service");
 const websocket_gateway_1 = require("../../../websocket/websocket.gateway");
+const inbound_1 = require("./inbound");
+const outbound_2 = require("./outbound");
 const types_2 = require("./types");
-const wrapper_1 = __importDefault(require("./wrapper"));
-const upload = (0, multer_1.default)({
-    limits: {
-        fileSize: config_1.config.parameters.maxUploadSize,
-    },
-    storage: (() => {
-        if (config_1.config.parameters.storageMode === 'memory') {
-            return (0, multer_1.memoryStorage)();
-        }
-        else {
-            return (0, multer_1.diskStorage)({});
-        }
-    })(),
-}).single('file');
 let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.default {
-    constructor(name, settingService, channelService, logger, eventEmitter, i18n, subscriberService, attachmentService, messageService, menuService, websocketGateway) {
-        super(name, settingService, channelService, logger);
-        this.eventEmitter = eventEmitter;
-        this.i18n = i18n;
-        this.subscriberService = subscriberService;
-        this.attachmentService = attachmentService;
-        this.messageService = messageService;
-        this.menuService = menuService;
-        this.websocketGateway = websocketGateway;
-    }
-    init() {
+    constructor(name) {
+        super(name);
+    }
+    async onModuleInit() {
+        await super.onModuleInit();
+        const OutboundMessageEncoderProvider = (0, outbound_2.createWebOutboundMessageEncoder)(this.getName());
+        const InboundEventDecoderProvider = (0, inbound_1.createWebInboundEventDecoder)(this.getName());
+        [this.outboundMessageEncoder, this.inboundEventDecoder] = await Promise.all([
+            this.createModuleRef(OutboundMessageEncoderProvider),
+            this.createModuleRef(InboundEventDecoderProvider),
+        ]);
         this.logger.debug('initialization ...');
     }
     async onWebSocketConnection(client) {
         try {
-            const settings = await this.getSettings();
             const handshake = client.handshake;
             const { channel } = handshake.query;
             const profile = client.request.session.web?.profile;
@@ -108,24 +55,47 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                 return;
             }
             let messages;
-            if (profile?.foreign_id) {
-                await client.join(profile.foreign_id);
-                const messagesHistory = await this.messageService.findHistoryUntilDate(profile);
-                messages = await this.formatMessages(messagesHistory.reverse());
+            let threadId;
+            if (profile?.foreignId) {
+                await client.join(profile.foreignId);
+                const thread = await this.threadService.resolveThread({
+                    subscriberId: profile.id,
+                    explicitThreadId: client.request.session.web?.threadId,
+                });
+                threadId = thread?.id;
+                const currentWebSession = client.request.session.web;
+                client.request.session.web = {
+                    profile: currentWebSession?.profile,
+                    threadId,
+                };
+                if (thread) {
+                    const messagesHistory = await this.messageService.findHistoryUntilDate(thread);
+                    messages = await this.formatMessages(messagesHistory.reverse());
+                }
+                else {
+                    messages = [];
+                }
             }
             this.logger.debug('WS connected .. sending settings');
+            const settings = await this.getSettings();
             try {
                 const menu = await this.menuService.getTree();
                 client.emit('settings', {
                     menu,
                     profile,
+                    thread_id: threadId ?? null,
                     messages,
                     ...settings,
                 });
             }
             catch (err) {
                 this.logger.warn('Unable to retrieve menu ', err);
-                client.emit('settings', { profile, messages, ...settings });
+                client.emit('settings', {
+                    profile,
+                    thread_id: threadId ?? null,
+                    messages,
+                    ...settings,
+                });
             }
         }
         catch (err) {
@@ -151,7 +121,7 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             if (incoming.message.type === button_1.PayloadType.location) {
                 const coordinates = incoming.message.coordinates;
                 return {
-                    type: types_2.Web.IncomingMessageType.location,
+                    type: types_2.Web.InboundMessageType.location,
                     data: {
                         coordinates: {
                             lat: coordinates.lat,
@@ -165,46 +135,29 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                     ? incoming.message.attachment[0]
                     : incoming.message.attachment;
                 return {
-                    type: types_2.Web.IncomingMessageType.file,
+                    type: types_2.Web.InboundMessageType.file,
                     data: {
                         type: attachmentPayload.type,
-                        url: await this.getPublicUrl(attachmentPayload.payload),
+                        url: await this.channelAttachmentService.getPublicUrl(this.getName(), attachmentPayload.payload),
                     },
                 };
             }
         }
         else {
             return {
-                type: types_2.Web.IncomingMessageType.text,
+                type: types_2.Web.InboundMessageType.text,
                 data: incoming.message,
             };
         }
     }
     async formatOutgoingHistoryMessage(outgoing) {
-        if ('buttons' in outgoing.message) {
-            return this._buttonsFormat(outgoing.message);
-        }
-        else if ('attachment' in outgoing.message) {
-            return this._attachmentFormat(outgoing.message);
-        }
-        else if ('quickReplies' in outgoing.message) {
-            return this._quickRepliesFormat(outgoing.message);
-        }
-        else if ('options' in outgoing.message) {
-            if (outgoing.message.options.display === 'carousel') {
-                return await this._carouselFormat(outgoing.message, {
-                    content: outgoing.message.options,
-                });
-            }
-            else {
-                return await this._listFormat(outgoing.message, {
-                    content: outgoing.message.options,
-                });
+        const envelope = (0, outbound_1.inferOutgoingMessageEnvelope)(outgoing.message);
+        const options = 'options' in outgoing.message
+            ? {
+                content: outgoing.message.options,
             }
-        }
-        else {
-            return this._textFormat(outgoing.message);
-        }
+            : {};
+        return await this.outboundMessageEncoder.encode(envelope, options);
     }
     isIncomingMessage(message) {
         return 'sender' in message && !!message.sender;
@@ -237,24 +190,46 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
         }
         return formattedMessages;
     }
-    async fetchHistory(req, until = new Date(), n = 30) {
-        const profile = req.session.web?.profile;
-        if (profile) {
-            const messages = await this.messageService.findHistoryUntilDate(profile, until, n);
-            return await this.formatMessages(messages.reverse());
+    normalizeThreadId(raw) {
+        if (typeof raw !== 'string') {
+            return undefined;
         }
-        return [];
+        const value = raw.trim();
+        return value.length > 0 ? value : undefined;
     }
-    async pollMessages(req, since = new Date(10e14), n = 30) {
+    getThreadIdFromQuery(req) {
+        const raw = req.query.thread_id;
+        const candidate = Array.isArray(raw) ? raw[0] : raw;
+        return this.normalizeThreadId(candidate);
+    }
+    getThreadIdFromBody(req) {
+        const body = req.body;
+        return this.normalizeThreadId(body?.thread_id);
+    }
+    async resolveThreadForHistory(req) {
         const profile = req.session.web?.profile;
-        if (profile) {
-            const messages = await this.messageService.findHistorySinceDate(profile, since, n);
-            return await this.formatMessages(messages);
+        if (!profile?.id) {
+            return null;
+        }
+        const explicitThreadId = this.getThreadIdFromQuery(req) ?? this.getThreadIdFromBody(req);
+        const thread = await this.threadService.resolveThread({
+            subscriberId: profile.id,
+            explicitThreadId,
+        });
+        if (req.session.web) {
+            req.session.web.threadId = thread?.id;
+        }
+        return thread;
+    }
+    async fetchHistory(req, until = new Date(), n = 30) {
+        const thread = await this.resolveThreadForHistory(req);
+        if (thread) {
+            const messages = await this.messageService.findHistoryUntilDate(thread, until, n);
+            return await this.formatMessages(messages.reverse());
         }
         return [];
     }
-    async validateCors(req, res) {
-        const settings = await this.getSettings();
+    async ensureValidCors(req, res) {
         if (!req.headers?.origin) {
             this.logger.debug('No origin ', req.headers);
             throw new Error('CORS - No origin provided!');
@@ -264,6 +239,7 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
         if (!allowedProtocols.has(originUrl.protocol)) {
             throw new Error('CORS - Invalid origin!');
         }
+        const settings = await this.getSettings();
         const origins = settings.allowed_domains.split(',');
         const foundOrigin = origins
             .filter((origin) => origin.trim() !== '*')
@@ -295,47 +271,58 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             res.set('Access-Control-Allow-Headers', 'content-type');
         }
     }
-    validateSession(req, res, next) {
-        if (!req.session.web?.profile?.id) {
-            this.logger.warn('No session ID to be found!', req.session);
-            return res
-                .status(403)
-                .json({ err: 'Web Channel Handler : Unauthorized!' });
-        }
-        else if ((this.isSocketRequest(req) &&
-            !!req.isSocket !== req.session.web.isSocket) ||
-            !Array.isArray(req.session.web.messageQueue)) {
-            this.logger.warn('Mixed channel request or invalid session data!', req.session);
-            return res
-                .status(403)
-                .json({ err: 'Web Channel Handler : Unauthorized!' });
+    async validateSession(req, res) {
+        if (req.session.web?.profile?.id) {
+            return req.session.web.profile;
         }
-        next(req.session.web?.profile);
-    }
-    async checkRequest(req, res) {
-        try {
-            await this.validateCors(req, res);
-        }
-        catch (err) {
-            this.logger.warn('Attempt to access from an unauthorized origin', err);
-            throw new Error('Unauthorized, invalid origin !');
+        const body = req.body;
+        const authorForeignId = typeof body?.author === 'string' && body.author.trim().length > 0
+            ? body.author.trim()
+            : undefined;
+        if (authorForeignId) {
+            try {
+                const subscriber = await this.subscriberService.findOneByForeignId(authorForeignId);
+                if (subscriber) {
+                    const thread = await this.threadService.resolveThread({
+                        subscriberId: subscriber.id,
+                        explicitThreadId: this.getThreadIdFromBody(req) ?? this.getThreadIdFromQuery(req),
+                    });
+                    req.session.web = {
+                        profile: subscriber,
+                        threadId: thread?.id,
+                    };
+                    this.logger.debug(`Recovered missing web session from author ${authorForeignId}`);
+                    return subscriber;
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Unable to recover missing session from author ${authorForeignId}`, error);
+            }
         }
+        this.logger.warn('No session ID to be found!', req.session);
+        res.status(403).json({ err: 'Web Channel Handler : Unauthorized!' });
+        return null;
     }
     async getOrCreateSession(req) {
         const data = req.query;
         const sessionProfile = req.session.web?.profile;
         if (sessionProfile) {
-            const subscriber = await this.subscriberService.findOneAndPopulate(sessionProfile.id);
+            const subscriber = await this.subscriberService.findOne(sessionProfile.id);
             if (!subscriber || !req.session.web) {
                 throw new Error('Subscriber session was not persisted in DB');
             }
+            const thread = await this.threadService.resolveThread({
+                subscriberId: subscriber.id,
+                explicitThreadId: req.session.web.threadId,
+            });
             req.session.web.profile = subscriber;
+            req.session.web.threadId = thread?.id;
             return subscriber;
         }
         const newProfile = {
-            foreign_id: this.generateId(),
-            first_name: data.first_name ? data.first_name.toString() : 'Anon.',
-            last_name: data.last_name ? data.last_name.toString() : 'Web User',
+            foreignId: this.generateId(),
+            firstName: data.first_name ? data.first_name.toString() : 'Anon.',
+            lastName: data.last_name ? data.last_name.toString() : 'Web User',
             assignedTo: null,
             assignedAt: null,
             lastvisit: new Date(),
@@ -351,90 +338,30 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             gender: 'male',
             country: '',
             labels: [],
-            context: { vars: {} },
-        };
-        const subscriber = await this.subscriberService.create(newProfile);
-        const profile = {
-            ...subscriber,
-            labels: [],
-            assignedTo: null,
-            avatar: null,
         };
+        const profile = await this.subscriberService.create(newProfile);
         req.session.web = {
             profile,
-            isSocket: this.isSocketRequest(req),
-            messageQueue: [],
-            polling: false,
         };
         return profile;
     }
-    getMessageQueue(req, res) {
-        if (this.isSocketRequest(req)) {
-            this.logger.warn('Polling not authorized when using websockets');
-            return res
-                .status(403)
-                .json({ err: 'Polling not authorized when using websockets' });
-        }
-        if (!(req.session && req.session.web && req.session.web?.profile?.id)) {
-            this.logger.warn('Must be connected to poll messages');
-            return res
-                .status(403)
-                .json({ err: 'Polling not authorized : Must be connected' });
-        }
-        if (req.session && req.session.web && req.session.web.polling) {
-            this.logger.warn('Poll rejected ... already requested');
-            return res
-                .status(403)
-                .json({ err: 'Poll rejected ... already requested' });
-        }
-        req.session.web.polling = true;
-        const fetchMessages = async (req, res, retrials = 1) => {
-            try {
-                if (!req.query.since)
-                    throw new common_1.BadRequestException(`QueryParam 'since' is missing`);
-                const since = new Date(req.query.since.toString());
-                const messages = await this.pollMessages(req, since);
-                if (messages.length === 0 && retrials <= 5) {
-                    setTimeout(async () => {
-                        await fetchMessages(req, res, retrials * 2);
-                    }, retrials * 1000);
-                }
-                else if (req.session.web) {
-                    req.session.web.polling = false;
-                    return res.status(200).json(messages.map((msg) => ['message', msg]));
-                }
-                else {
-                    this.logger.error('Polling failed .. no session data');
-                    return res.status(500).json({ err: 'No session data' });
-                }
-            }
-            catch (err) {
-                if (req.session.web) {
-                    req.session.web.polling = false;
-                }
-                this.logger.error('Polling failed', err);
-                return res.status(500).json({ err: 'Polling failed' });
-            }
-        };
-        fetchMessages(req, res);
-    }
     async subscribe(req, res) {
-        this.logger.debug('subscribe (isSocket=' + this.isSocketRequest(req) + ')');
+        this.logger.debug('subscribe (isSocket=true)');
         try {
             const profile = await this.getOrCreateSession(req);
-            if (this.isSocketRequest(req)) {
-                try {
-                    await req.socket.join(profile.foreign_id);
-                }
-                catch (err) {
-                    this.logger.error('Unable to subscribe via websocket', err);
-                }
+            try {
+                await req.socket.join(profile.foreignId);
+            }
+            catch (err) {
+                this.logger.error('Unable to subscribe via websocket', err);
             }
-            const criteria = 'since' in req.query
-                ? req.query.since
-                : req.body?.since || undefined;
+            const criteria = 'since' in req.query ? req.query.since : req.body?.since || undefined;
             const messages = await this.fetchHistory(req, criteria);
-            return res.status(200).json({ profile, messages });
+            return res.status(200).json({
+                profile,
+                messages,
+                thread_id: req.session.web?.threadId ?? null,
+            });
         }
         catch (err) {
             this.logger.warn('Unable to subscribe ', err);
@@ -445,15 +372,16 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
         try {
             const { type, data } = req.body;
             if (!req.session.web?.profile?.id) {
-                this.logger.debug('No session');
+                this.logger.debug('No session provided');
                 return null;
             }
-            if (type !== types_2.Web.IncomingMessageType.file ||
-                !('file' in data) ||
-                !data.file) {
+            if (type !== types_2.Web.InboundMessageType.file) {
                 this.logger.debug('No files provided');
                 return null;
             }
+            if (!('file' in data) || !data.file) {
+                throw new Error('File payload is missing');
+            }
             const size = Buffer.byteLength(data.file);
             if (size > config_1.config.parameters.maxUploadSize) {
                 throw new Error('Max upload size has been exceeded');
@@ -473,158 +401,142 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             throw new Error('Unable to upload file!');
         }
     }
-    async handleWebUpload(req, _res) {
-        try {
-            if (!req.session.web?.profile?.id) {
-                this.logger.debug('Upload denied, no session is defined');
-                return null;
-            }
-            if (!req.file) {
-                this.logger.debug('No files provided');
-                return null;
-            }
-            return await this.attachmentService.store(req.file, {
-                name: req.file.originalname,
-                size: req.file.size,
-                type: req.file.mimetype,
-                resourceRef: types_1.AttachmentResourceRef.MessageAttachment,
-                access: types_1.AttachmentAccess.Private,
-                createdByRef: types_1.AttachmentCreatedByRef.Subscriber,
-                createdBy: req.session.web.profile.id,
-            });
-        }
-        catch (err) {
-            this.logger.error('Unable to store uploaded file', err);
-            throw err;
-        }
-    }
-    async handleUpload(req, res) {
-        if (!req.session.web) {
-            this.logger.debug('No session provided');
-            return null;
-        }
-        if (this.isSocketRequest(req)) {
-            return this.handleWsUpload(req);
-        }
-        else {
-            return this.handleWebUpload(req, res);
-        }
-    }
     getIpAddress(req) {
-        if (this.isSocketRequest(req)) {
-            return req.socket.handshake.address;
-        }
-        else if (Array.isArray(req.ips) && req.ips.length > 0) {
-            return req.ips.join(',');
-        }
-        else {
-            return req.ip || '0.0.0.0';
-        }
+        return req.socket.handshake.address;
     }
     getChannelAttributes(req) {
         return {
-            isSocket: this.isSocketRequest(req),
+            isSocket: true,
             ipAddress: this.getIpAddress(req),
             agent: req.headers['user-agent'] || 'browser',
         };
     }
-    _handleEvent(req, res) {
+    async handleEvent(req, res, workflowId) {
         if (!req.body) {
             this.logger.debug('Empty body');
             res.status(400).json({ err: 'Web Channel Handler : Bad Request!' });
             return;
         }
-        else {
-            req.body.data =
-                typeof req.body.data === 'string'
-                    ? JSON.parse(req.body.data)
-                    : req.body.data;
-        }
-        this.validateSession(req, res, async (profile) => {
-            const body = req.body;
-            const channelAttrs = this.getChannelAttributes(req);
-            const event = new wrapper_1.default(this, body, channelAttrs);
-            if (event._adapter.eventType === message_1.StdEventType.message) {
-                if (event._adapter.messageType === message_1.IncomingMessageType.attachments) {
+        else if (typeof req.body === 'object' &&
+            req.body !== null &&
+            'data' in req.body) {
+            const payload = req.body;
+            payload.data =
+                typeof payload.data === 'string'
+                    ? JSON.parse(payload.data)
+                    : payload.data;
+        }
+        const profile = await this.validateSession(req, res);
+        if (!profile) {
+            return;
+        }
+        const channelAttrs = this.getChannelAttributes(req);
+        let events;
+        try {
+            events = this.inboundEventDecoder.createEvents(req.body, channelAttrs);
+        }
+        catch (err) {
+            this.logger.warn('Invalid event payload', err);
+            return void res
+                .status(400)
+                .json({ err: 'Web Channel Handler : Bad Request!' });
+        }
+        if (!events.length) {
+            return void res
+                .status(400)
+                .json({ err: 'Web Channel Handler : Bad Request!' });
+        }
+        const explicitThreadId = this.getThreadIdFromBody(req) ??
+            this.getThreadIdFromQuery(req) ??
+            req.session.web?.threadId;
+        const responseBody = events[0].getRaw();
+        for (const event of events) {
+            event.setHandler(this);
+            if (explicitThreadId) {
+                event.setThreadId(explicitThreadId);
+            }
+            event.setInitiator(profile);
+            event.setWorkflowId(workflowId);
+            if (event.getEventType() === message_1.StdEventType.message) {
+                const messageEvent = event;
+                if (messageEvent instanceof inbound_1.AttachmentMessageInboundEvent) {
                     try {
-                        const attachment = await this.handleUpload(req, res);
+                        const attachment = await this.handleWsUpload(req);
                         if (attachment) {
-                            event._adapter.attachment = attachment;
-                            event._adapter.raw.data = {
-                                type: attachment_entity_1.AttachmentOrmEntity.getTypeByMime(attachment.type),
-                                url: await this.getPublicUrl(attachment),
-                            };
+                            messageEvent.setUploadedAttachment(attachment);
+                            messageEvent.setUploadedRawData(attachment_entity_1.AttachmentOrmEntity.getTypeByMime(attachment.type), await this.channelAttachmentService.getPublicUrl(this.getName(), attachment));
                         }
                     }
                     catch (err) {
                         this.logger.warn('Unable to upload file ', err);
-                        return res
+                        return void res
                             .status(403)
                             .json({ err: 'Web Channel Handler : File upload failed!' });
                     }
                 }
-                if (body.sync && body.author === 'chatbot') {
+                if (messageEvent.isSyncFromChatbot()) {
+                    const thread = await this.threadService.resolveThread({
+                        subscriberId: profile.id,
+                        explicitThreadId,
+                    });
+                    if (!thread) {
+                        return void res.status(409).json({
+                            err: 'Web Channel Handler : No thread available before first user message',
+                        });
+                    }
+                    messageEvent.setThreadId(thread.id);
+                    if (req.session.web) {
+                        req.session.web.threadId = thread.id;
+                    }
                     const sentMessage = {
-                        mid: event.getId(),
-                        message: event.getMessage(),
+                        mid: messageEvent.getId(),
+                        message: messageEvent.getMessage(),
                         recipient: profile.id,
+                        thread: thread.id,
                         read: true,
                         delivery: true,
                     };
-                    this.eventEmitter.emit('hook:chatbot:sent', sentMessage, event);
-                    return res.status(200).json(event._adapter.raw);
+                    this.eventEmitter.emit('hook:chatbot:sent', sentMessage, messageEvent);
+                    continue;
                 }
-                else {
-                    event._adapter.raw.mid = this.generateId();
-                    event._adapter.raw.author = profile.foreign_id;
+                messageEvent.setMessageId(this.generateId());
+                messageEvent.setAuthorForeignId(profile.foreignId);
+                messageEvent.setCreatedAt(new Date());
+                this.broadcast(profile, message_1.StdEventType.message, messageEvent.getRaw());
+                await this.eventEmitter.emitAsync('hook:chatbot:message', messageEvent);
+                const resolvedThreadId = messageEvent.getThreadId();
+                if (resolvedThreadId) {
+                    messageEvent.setThreadIdOnRaw(resolvedThreadId);
+                    if (req.session.web) {
+                        req.session.web.threadId = resolvedThreadId;
+                    }
                 }
+                continue;
             }
-            event.setSender(profile);
             const type = event.getEventType();
-            if (type) {
-                this.broadcast(profile, type, event._adapter.raw);
-                this.eventEmitter.emit(`hook:chatbot:${type}`, event);
+            const threadId = event.getThreadId();
+            if (threadId) {
+                event.setThreadIdOnRaw(threadId);
             }
-            else {
-                this.logger.error('Webhook received unknown event ', event);
-            }
-            res.status(200).json(event._adapter.raw);
-        });
+            this.broadcast(profile, type, event.getRaw());
+            this.eventEmitter.emit(`hook:chatbot:${type}`, event);
+        }
+        res.status(200).json(responseBody);
     }
     isSocketRequest(req) {
         return 'isSocket' in req && req.isSocket;
     }
-    async handle(req, res) {
-        const settings = await this.getSettings();
+    async handle(req, res, workflowId) {
+        if (!this.isSocketRequest(req)) {
+            this.logger.warn('Web channel over HTTP is no longer supported. Use Socket.IO transport.');
+            return res
+                .status(403)
+                .json({ err: 'Web Channel Handler : Unauthorized!' });
+        }
         try {
-            await this.checkRequest(req, res);
+            await this.ensureValidCors(req, res);
             if (req.method === 'GET') {
-                if (!this.isSocketRequest(req) && req.query._get) {
-                    switch (req.query._get) {
-                        case 'settings':
-                            this.logger.debug('connected .. sending settings');
-                            try {
-                                const menu = await this.menuService.getTree();
-                                return res.status(200).json({
-                                    menu,
-                                    server_date: new Date().toISOString(),
-                                    ...settings,
-                                });
-                            }
-                            catch (err) {
-                                this.logger.warn('Unable to retrieve menu ', err);
-                                return res.status(500).json({ err: 'Unable to retrieve menu' });
-                            }
-                        case 'polling':
-                            return this.getMessageQueue(req, res);
-                        default:
-                            this.logger.error('Webhook received unknown command');
-                            return res
-                                .status(500)
-                                .json({ err: 'Webhook received unknown command' });
-                    }
-                }
-                else if (req.query._disconnect) {
+                if (req.query._disconnect) {
                     req.session.web = undefined;
                     return res.status(200).json({ _disconnect: true });
                 }
@@ -633,7 +545,7 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
                 }
             }
             else {
-                return this._handleEvent(req, res);
+                return this.handleEvent(req, res, workflowId);
             }
         }
         catch (err) {
@@ -644,190 +556,22 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
         }
     }
     generateId() {
-        return 'web-' + (0, uuid_1.v4)();
-    }
-    _textFormat(message, _options) {
-        return {
-            type: types_2.Web.OutgoingMessageType.text,
-            data: message,
-        };
-    }
-    _quickRepliesFormat(message, _options) {
-        return {
-            type: types_2.Web.OutgoingMessageType.quick_replies,
-            data: {
-                text: message.text,
-                quick_replies: message.quickReplies,
-            },
-        };
-    }
-    _buttonsFormat(message, _options) {
-        return {
-            type: types_2.Web.OutgoingMessageType.buttons,
-            data: {
-                text: message.text,
-                buttons: message.buttons,
-            },
-        };
-    }
-    async _attachmentFormat(message, _options) {
-        const payload = {
-            type: types_2.Web.OutgoingMessageType.file,
-            data: {
-                type: message.attachment.type,
-                url: await this.getPublicUrl(message.attachment.payload),
-            },
-        };
-        if (message.quickReplies && message.quickReplies.length > 0) {
-            return {
-                ...payload,
-                data: {
-                    ...payload.data,
-                    quick_replies: message.quickReplies,
-                },
-            };
-        }
-        return payload;
-    }
-    async _formatElements(data, options) {
-        if (!options.content || !options.content.fields) {
-            throw new Error('Content options are missing the fields');
-        }
-        const fields = options.content.fields;
-        const buttons = options.content.buttons;
-        const result = [];
-        for (const item of data) {
-            const element = {
-                title: item[fields.title],
-                buttons: item.buttons || [],
-            };
-            if (fields.subtitle && item[fields.subtitle]) {
-                element.subtitle = item[fields.subtitle];
-            }
-            if (fields.image_url && item[fields.image_url]) {
-                const attachmentRef = typeof item[fields.image_url] === 'string'
-                    ? { url: item[fields.image_url] }
-                    : item[fields.image_url].payload;
-                element.image_url = await this.getPublicUrl(attachmentRef);
-            }
-            buttons.forEach((button, index) => {
-                const btn = { ...button };
-                if (btn.type === button_1.ButtonType.web_url) {
-                    const urlField = fields.url;
-                    btn.url =
-                        urlField && item[urlField]
-                            ? item[urlField]
-                            : content_entity_1.ContentOrmEntity.getUrl(item);
-                    if (!btn.url.startsWith('http')) {
-                        btn.url = 'https://' + btn.url;
-                    }
-                    if (!element.default_action) {
-                        const { title: _title, ...defaultAction } = btn;
-                        element.default_action = defaultAction;
-                    }
-                }
-                else {
-                    if ('action_payload' in fields &&
-                        fields.action_payload &&
-                        fields.action_payload in item) {
-                        btn.payload = btn.title + ':' + item[fields.action_payload];
-                    }
-                    else {
-                        const postback = content_entity_1.ContentOrmEntity.getPayload(item);
-                        btn.payload = btn.title + ':' + postback;
-                    }
-                }
-                if (index === 0 && fields.action_title && item[fields.action_title]) {
-                    btn.title = item[fields.action_title];
-                }
-                element.buttons?.push(btn);
-            });
-            if (Array.isArray(element.buttons) && element.buttons.length === 0) {
-                delete element.buttons;
-            }
-            result.push(element);
-        }
-        return result;
-    }
-    async _listFormat(message, options) {
-        const data = message.elements || [];
-        const pagination = message.pagination;
-        let buttons = [], elements = [];
-        if (!data.length) {
-            this.logger.error('Insufficient content count (must be >= 0 for list)');
-            throw new Error('Insufficient content count (list >= 0)');
-        }
-        if (pagination.total - pagination.skip - pagination.limit > 0) {
-            buttons = [
-                {
-                    type: button_1.ButtonType.postback,
-                    title: this.i18n.t('View More'),
-                    payload: constants_1.VIEW_MORE_PAYLOAD,
-                },
-            ];
-        }
-        elements = await this._formatElements(data, options);
-        const topElementStyle = options.content?.top_element_style
-            ? {
-                top_element_style: options.content?.top_element_style,
-            }
-            : {};
-        return {
-            type: types_2.Web.OutgoingMessageType.list,
-            data: {
-                elements,
-                buttons,
-                ...topElementStyle,
-            },
-        };
-    }
-    async _carouselFormat(message, options) {
-        const data = message.elements || [];
-        if (data.length === 0) {
-            this.logger.error('Insufficient content count (must be > 0 for carousel)');
-            throw new Error('Insufficient content count (carousel > 0)');
-        }
-        const elements = await this._formatElements(data, options);
-        return {
-            type: types_2.Web.OutgoingMessageType.carousel,
-            data: {
-                elements,
-            },
-        };
-    }
-    async _formatMessage(envelope, options) {
-        switch (envelope.format) {
-            case message_1.OutgoingMessageFormat.attachment:
-                return await this._attachmentFormat(envelope.message, options);
-            case message_1.OutgoingMessageFormat.buttons:
-                return this._buttonsFormat(envelope.message, options);
-            case message_1.OutgoingMessageFormat.carousel:
-                return await this._carouselFormat(envelope.message, options);
-            case message_1.OutgoingMessageFormat.list:
-                return await this._listFormat(envelope.message, options);
-            case message_1.OutgoingMessageFormat.quickReplies:
-                return this._quickRepliesFormat(envelope.message, options);
-            case message_1.OutgoingMessageFormat.text:
-                return this._textFormat(envelope.message, options);
-            default:
-                throw new Error('Unknown message format');
-        }
+        return `${this.name}-${(0, uuid_1.v4)()}`;
     }
     broadcast(subscriber, type, content, excludedRooms = []) {
-        const channelData = subscriber.channel;
-        if (channelData.data?.isSocket) {
-            this.websocketGateway.broadcast(subscriber, type, content, excludedRooms);
-        }
-        else {
-        }
+        this.websocketGateway.broadcast(subscriber, type, content, excludedRooms);
     }
-    async sendMessage(event, envelope, options, _context) {
-        const messageBase = await this._formatMessage(envelope, options);
-        const subscriber = event.getSender();
+    async sendMessage(event, envelope, options) {
+        if (envelope.format === message_1.OutgoingMessageFormat.system) {
+            throw new outbound_1.UnsupportedOutgoingFormatError(envelope.format);
+        }
+        const messageBase = await this.outboundMessageEncoder.encode(envelope, options ?? {});
+        const subscriber = event.getInitiator();
         const message = {
             ...messageBase,
             mid: this.generateId(),
             author: 'chatbot',
+            thread_id: event.getThreadId(),
             createdAt: new Date(),
             handover: !!(options && options.assignTo),
         };
@@ -865,7 +609,7 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
         });
     }
     async getSubscriberData(event) {
-        const sender = event.getSender();
+        const sender = event.getInitiator();
         const { id: _id, createdAt: _createdAt, updatedAt: _updatedAt, ...rest } = sender;
         const subscriber = {
             ...rest,
@@ -887,48 +631,34 @@ let BaseWebChannelHandler = class BaseWebChannelHandler extends Handler_1.defaul
             return true;
         }
         else {
-            const message = await this.messageService.findOne({
-                where: {
-                    recipient: { id: subscriberId },
-                    message: (0, typeorm_1.Raw)((alias) => `
-              (
-                jsonb_typeof(${alias}->'attachment') = 'object'
-                AND (${alias}->'attachment'->'payload'->>'id') = :attId
-              ) OR (
-                jsonb_typeof(${alias}->'attachment') = 'array'
-                AND EXISTS (
-                  SELECT 1 FROM jsonb_array_elements(${alias}->'attachment') a
-                  WHERE a->'payload'->>'id' = :attId
-                )
-              )
-            `, { attId: attachment.id }),
-                },
-            });
-            return !!message;
-        }
-    }
-    async middleware(req, res, next) {
-        if (!this.isSocketRequest(req)) {
-            if (req.headers['content-type']?.includes('multipart/form-data')) {
-                return upload(req, res, next);
-            }
-            else if (req.headers['content-type']?.includes('text/plain')) {
-                const textParser = body_parser_1.default.text({ type: 'text/plain' });
-                return textParser(req, res, () => {
-                    try {
-                        req.body =
-                            typeof req.body === 'string' ? JSON.parse(req.body) : req.body;
-                        next();
-                    }
-                    catch (err) {
-                        next(err);
-                    }
-                });
-            }
+            return await this.messageService.isAttachmentAccessibleBySubscriber(subscriberId, attachment.id);
         }
-        next();
     }
 };
+__decorate([
+    (0, common_1.Inject)(subscriber_service_1.SubscriberService),
+    __metadata("design:type", subscriber_service_1.SubscriberService)
+], BaseWebChannelHandler.prototype, "subscriberService", void 0);
+__decorate([
+    (0, common_1.Inject)(message_service_1.MessageService),
+    __metadata("design:type", message_service_1.MessageService)
+], BaseWebChannelHandler.prototype, "messageService", void 0);
+__decorate([
+    (0, common_1.Inject)(menu_service_1.MenuService),
+    __metadata("design:type", menu_service_1.MenuService)
+], BaseWebChannelHandler.prototype, "menuService", void 0);
+__decorate([
+    (0, common_1.Inject)(websocket_gateway_1.WebsocketGateway),
+    __metadata("design:type", websocket_gateway_1.WebsocketGateway)
+], BaseWebChannelHandler.prototype, "websocketGateway", void 0);
+__decorate([
+    (0, common_1.Inject)(thread_service_1.ThreadService),
+    __metadata("design:type", thread_service_1.ThreadService)
+], BaseWebChannelHandler.prototype, "threadService", void 0);
+__decorate([
+    (0, common_1.Inject)(channel_attachment_service_1.ChannelAttachmentService),
+    __metadata("design:type", channel_attachment_service_1.ChannelAttachmentService)
+], BaseWebChannelHandler.prototype, "channelAttachmentService", void 0);
 __decorate([
     (0, event_emitter_1.OnEvent)('hook:websocket:connection', { async: true }),
     __metadata("design:type", Function),
@@ -943,16 +673,7 @@ __decorate([
 ], BaseWebChannelHandler.prototype, "broadcastError", null);
 BaseWebChannelHandler = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [String, setting_service_1.SettingService,
-        channel_service_1.ChannelService,
-        logger_service_1.LoggerService,
-        event_emitter_1.EventEmitter2,
-        i18n_service_1.I18nService,
-        subscriber_service_1.SubscriberService,
-        attachment_service_1.AttachmentService,
-        message_service_1.MessageService,
-        menu_service_1.MenuService,
-        websocket_gateway_1.WebsocketGateway])
+    __metadata("design:paramtypes", [String])
 ], BaseWebChannelHandler);
 exports.default = BaseWebChannelHandler;
 //# sourceMappingURL=base-web-channel.js.map