Merge pull request #16 from Dialogue-Bot/DIAL-24-Add-receive-message-from-channels

DIAL-24-Add-receive-message-from-channels

Author: khanh1902

server/src/channels/base.channel.ts

@@ -7,15 +7,11 @@ export class BaseChannel {
     contactName: string;
     channelType: string;
 
-    constructor(id: string, contactId: string, contactName: string, channelType: string,) {
+    constructor(id: string, contactId: string, contactName: string, channelType: string) {
         this.id = id;
         this.contactId = contactId;
         this.contactName = contactName;
         this.channelType = channelType;
-
-        if (channelType && contactName && contactId) {
-            console.log(`Init channel ${channelType} - ${contactName} ${contactId}`);
-        }
     }
 
     public async postMessageToBot({ userId, data }) {

server/src/channels/messenger.channel.ts

@@ -39,4 +39,8 @@ export class MessengerChannel extends BaseChannel {
             return null;
         }
     }
+
+    public async prepareMessage(req: Request, res: Response) {
+
+    }
 }

server/src/constants/index.ts

@@ -35,6 +35,7 @@ export const ENDPOINTS = {
    WEBHOOK: {
       INDEX: '/webhook',
       VERIFY: '/webhook/:contactId',
+      INCOMING_MSG: '/webhook/:contactId',
    }
 };
 

server/src/controllers/webhook.controller.ts

@@ -15,4 +15,10 @@ export class WebhookController {
 
         res.status(StatusCodes.OK).send(data);
     });
+
+    public handleIncomingMessage = catchAsync(async (req, res) => {
+        res.status(StatusCodes.OK);
+
+        return await this.webhookService.handleIncomingMessage(req.params.contactId, req, res);
+    });
 }

server/src/routes/webhook.route.ts

@@ -14,5 +14,10 @@ export class WebhookRoute implements Routes {
             ENDPOINTS.WEBHOOK.VERIFY,
             this.controller.verifyWebhook
         );
+
+        this.router.post(
+            ENDPOINTS.WEBHOOK.INCOMING_MSG,
+            this.controller.handleIncomingMessage
+        );
     }
 }

server/src/services/channels.service.ts

@@ -58,12 +58,25 @@ export class ChannelService {
         return newChannel;
     }
 
-    public async findOneById(id: string) {
-        const channel = await db.query.channels.findFirst({
-            where: eq(channels.id, id),
-        });
+    public async findOneByContactId(contactId: string) {
+        const expectedChannel = await db.select({
+            id: channels.id,
+            contactId: channels.contactId,
+            contactName: channels.contactName,
+            channelType: channelTypes.name,
+            credentials: channels.credentials,
+        })
+            .from(channels)
+            .where(
+                and(eq(channels.contactId, contactId),
+                    eq(channels.deleted, false)
+                )
+            )
+            .innerJoin(channelTypes, eq(channels.channelTypeId, channelTypes.id));
 
-        return channel;
+        if (!expectedChannel) return
+
+        return expectedChannel[0];
     }
 
     public async updateById(id: string, fields: TUpdateChannel) {
@@ -78,9 +91,7 @@ export class ChannelService {
             );
         }
 
-        const contactIdExisted = await db.query.channels.findFirst({
-            where: eq(channels.contactId, fields.contactId),
-        });
+        const contactIdExisted = this.channels.find(c => c.contactId == fields.contactId);
 
         if (contactIdExisted && fields.contactId !== channelExisted.contactId) {
             throw new HttpException(
@@ -193,12 +204,15 @@ export class ChannelService {
     }
 
     initChannel(channel: ChannelInfo) {
-        switch (channel.channelType) {
+        const { id, contactId, contactName, channelType, credentials } = channel;
+
+        console.log(`Init channel: ${channelType} - ${contactName} ${contactId}`);
+
+        switch (channelType) {
             case 'MSG':
-                const { id, contactId, contactName, channelType, credentials } = channel;
                 return new MessengerChannel(id, contactId, contactName, channelType, credentials);
             default:
-                console.log(`Does not support channel type ${channel.channelType}`);
+                console.log(`Init channel: Does not support channel type ${channel.channelType}`);
                 break;
         }
 
@@ -215,7 +229,12 @@ export class ChannelService {
                 credentials: channels.credentials,
             })
             .from(channels)
-            .where(eq(channels.deleted, false))
+            .where(
+                and(
+                    eq(channels.deleted, false),
+                    eq(channels.active, true)
+                )
+            )
             .innerJoin(channelTypes, eq(channels.channelTypeId, channelTypes.id))
 
         contacts.forEach((c) => {

server/src/services/webhook.service.ts

@@ -1,35 +1,21 @@
 import { MessengerChannel } from "@/channels/messenger.channel";
 import { LOCALE_KEY } from "@/constants";
-import { db } from "@/database/db";
-import { channelTypes, channels } from "@/database/schema";
 import { HttpException } from "@/exceptions/http-exception";
 import { LocaleService } from "@/i18n/ctx";
-import { and, eq } from "drizzle-orm";
 import { Request, Response } from "express";
 import { StatusCodes } from "http-status-codes";
 import { Inject, Service } from "typedi";
+import { ChannelService } from "./channels.service";
 
 @Service()
 export class WebhookService {
     constructor(
-        @Inject(LOCALE_KEY) private readonly localeService: LocaleService
+        @Inject(LOCALE_KEY) private readonly localeService: LocaleService,
+        private readonly chanelService: ChannelService
     ) { }
 
     public async verifyWebhook(contactId: string, req: Request, res: Response) {
-        const expectedChannel = await db.select({
-            id: channels.id,
-            contactId: channels.contactId,
-            contactName: channels.contactName,
-            channelType: channelTypes.name,
-            credentials: channels.credentials,
-        })
-            .from(channels)
-            .where(
-                and(eq(channels.contactId, contactId),
-                    eq(channels.deleted, false)
-                )
-            )
-            .innerJoin(channelTypes, eq(channels.channelTypeId, channelTypes.id));
+        const expectedChannel = await this.chanelService.findOneByContactId(contactId);
 
         if (!expectedChannel) {
             throw new HttpException(
@@ -40,9 +26,9 @@ export class WebhookService {
 
         let verifyResult = null;
 
-        if (expectedChannel[0]) {
-            const { id, contactId, contactName, channelType, credentials } = expectedChannel[0];
-            switch (expectedChannel[0].channelType) {
+        if (expectedChannel) {
+            const { id, contactId, contactName, channelType, credentials } = expectedChannel;
+            switch (channelType) {
                 case 'MSG':
                     const messengerChannel = new MessengerChannel(id, contactId, contactName, channelType, credentials);
                     verifyResult = messengerChannel.verifyWebhook(req, res);
@@ -58,4 +44,29 @@ export class WebhookService {
 
         return verifyResult;
     }
+
+    public async handleIncomingMessage(contactId: string, req: Request, res: Response) {
+        const expectedChannel = await this.chanelService.findOneByContactId(contactId);
+
+        if (!expectedChannel) {
+            console.log('Incoming message: Can not find channel with id ', req.params.id);
+            return;
+        }
+
+        const { id, contactName, channelType, credentials } = expectedChannel;
+
+        let prepareMessage = null;
+
+        switch (channelType) {
+            case 'MSG':
+                const messengerChannel = new MessengerChannel(id, contactId, contactName, channelType, credentials);
+                prepareMessage = await messengerChannel.prepareMessage(req, res);
+                break;
+            default:
+                console.log(`Incoming message: Does not support channel type ${channelType}`);
+                break;
+        }
+
+        return prepareMessage;
+    }
 }