Merge remote-tracking branch 'origin/main' into DIAL-21-Ui-settings

Author: hi02102002

server/package-lock.json

@@ -31,6 +31,7 @@
       "@paralleldrive/cuid2": "^2.2.2",
       "@react-email/components": "^0.0.15",
       "@react-email/render": "0.0.7",
+      "axios": "^1.6.7",
       "bcrypt": "^5.0.1",
       "bullmq": "^5.1.5",
       "class-transformer": "^0.5.1",

server/package.json

@@ -0,0 +1,56 @@
+import { BOT_ENDPOINT, PUBLIC_DOMAIN } from "@/config";
+import axios from "axios";
+
+export class BaseChannel {
+    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;
+    }
+
+    public async postMessageToBot({ userId, message = '', data }) {
+        const uid = this.initConversationId(userId);
+        try {
+            const postMsg = await axios({
+                method: 'POST',
+                url: BOT_ENDPOINT,
+                data: {
+                    conversation: {
+                        id: uid,
+                    },
+                    from: {
+                        id: userId,
+                    },
+                    recipient: {
+                        id: this.contactId,
+                    },
+                    data: data || false,
+                    text: message,
+                    type: 'message',
+                    id: uid,
+                    channelId: this.channelType,
+                    serviceUrl: PUBLIC_DOMAIN,
+                },
+            })
+            if (postMsg.data.success) {
+                console.log(
+                    `[${this.channelType} - ${this.contactName} ${this.contactId}] - [Conversation ID: ${uid}] - [Send message to bot - Message: ${message}] - [Data: ${data}]`
+                )
+            }
+        } catch (error) {
+            console.log(
+                `[${this.channelType} - ${this.contactName} ${this.contactId}] - [Conversation ID: ${uid}] - [Can not send message to bot - Message: ${message}] - [Error: ${error.message}]`
+            );
+        }
+    }
+
+    initConversationId(userId: string) {
+        return this.contactId + '-' + userId
+    }
+}

server/src/channels/base.channel.ts

@@ -0,0 +1,75 @@
+import { Helper } from "@/utils/helper";
+import { Request, Response } from "express";
+import { BaseChannel } from "./base.channel";
+
+export class MessengerChannel extends BaseChannel {
+    pageToken: string;
+    webhookSecret: string;
+    messengerPostURL: string;
+    credentials: string;
+
+    constructor(id: string, contactId: string, contactName: string, channelType: string, credentials: string) {
+        super(id, contactId, contactName, channelType);
+
+        let parseCredentials: MessengerChannel;
+
+        this.credentials = credentials;
+
+        if (credentials && typeof credentials == 'string') parseCredentials = JSON.parse(credentials);
+
+        if (parseCredentials) {
+            this.pageToken = parseCredentials.pageToken;
+            this.webhookSecret = parseCredentials.webhookSecret;
+        }
+
+        this.channelType = channelType;
+        this.messengerPostURL = `https://graph.facebook.com/v18.0/me/messages?access_token=`;
+    }
+
+    public verifyWebhook(req: Request, res: Response) {
+        let mode = req.query['hub.mode'];
+        let token = req.query['hub.verify_token'];
+        let challenge = req.query['hub.challenge'];
+
+        if (mode === 'subscribe' && this.webhookSecret == token) {
+            console.log(`channel ${this.channelType} - ${this.contactName} ${this.contactId} webhook verified!`);
+            return challenge;
+        } else {
+            console.error(`Verification channel ${this.channelType} - ${this.contactName} ${this.contactId} failed!`);
+            return;
+        }
+    }
+
+    public async prepareMessage(req: Request, res: Response) {
+        const { object, entry } = req.body;
+
+        if (object != 'page' || !Array.isArray(entry)) return;
+
+        entry.forEach(pageEntry => {
+            if (!Array.isArray(pageEntry.messaging)) return;
+
+            pageEntry.messaging.forEach(async (messagingEvent) => {
+                if (messagingEvent.messaging_customer_information)
+                    return this.sendAddressToBot({
+                        userId: messagingEvent.sender.id,
+                        address: messagingEvent.messaging_customer_information.screens[0].responses,
+                    });
+
+                if (!messagingEvent.message && !messagingEvent.postback) return;
+
+                const senderId = messagingEvent.sender.id;
+                const messageText = messagingEvent.message && messagingEvent.message.text;
+                const payload = messagingEvent.postback && messagingEvent.postback.payload;
+                const quick_reply = messagingEvent.message && messagingEvent.message.quick_reply;
+
+                if (senderId == this.contactId) return; //Agent replied to user => skip
+
+                return this.postMessageToBot({ userId: senderId, message: messageText || payload, data: null });
+            });
+        });
+    }
+
+    sendAddressToBot({ userId, address }) {
+        return this.postMessageToBot({ userId, message: 'ADDRESS', data: { USER_INFORMATION: Helper.arrayToObj(address) } });
+    }
+}

server/src/channels/messenger.channel.ts

@@ -28,4 +28,6 @@ export const {
    FIREBASE_UNIVERSE_DOMAIN,
    FIREBASE_DATABASE_URL,
    SIGNATURE_SECRET,
+   PUBLIC_DOMAIN,
+   BOT_ENDPOINT,
 } = process.env;

server/src/config/index.ts

@@ -39,7 +39,12 @@ export const ENDPOINTS = {
    USER: {
       UPDATE_INFO: '/user/update-info',
       CHANGE_PASSWORD: '/user/change-password',
-   }
+   },
+   WEBHOOK: {
+      INDEX: '/webhook',
+      VERIFY: '/webhook/:contactId',
+      INCOMING_MSG: '/webhook/:contactId',
+   },
 };
 
 export const LOCALE_KEY = 'lang';

server/src/constants/index.ts

@@ -1,6 +1,7 @@
 import { LOCALE_KEY } from "@/constants";
 import { PagingDTO } from "@/dtos/paging.dto";
 import { LocaleService } from "@/i18n/ctx";
+import { RequestWithUser } from "@/interfaces/auth.interface";
 import { ChannelService } from "@/services/channels.service";
 import { catchAsync } from "@/utils/catch-async";
 import { plainToClass } from "class-transformer";
@@ -11,38 +12,40 @@ export class ChannelController {
     public channelService = Container.get(ChannelService);
     public localeService = Container.get<LocaleService>(LOCALE_KEY);
 
-    public createChannel = catchAsync(async (req, res) => {
+    public createChannel = catchAsync(async (req: RequestWithUser, res) => {
+        req.body.userId = req.user?.id;
         await this.channelService.create(req.body);
         res.status(StatusCodes.OK).json({
             message: this.localeService.i18n().CHANNEL.CREATE_SUCCESS(),
         });
     });
 
-    public updateChannel = catchAsync(async (req, res) => {
+    public updateChannel = catchAsync(async (req: RequestWithUser, res) => {
+        req.body.userId = req.user?.id;
         await this.channelService.updateById(req.params.id, req.body);
         res.status(StatusCodes.OK).json({
             message: this.localeService.i18n().CHANNEL.UPDATE_SUCCESS(),
         });
     })
 
-    public deleteChannel = catchAsync(async (req, res) => {
-        await this.channelService.deleteById(req.params.id);
+    public deleteChannel = catchAsync(async (req: RequestWithUser, res) => {
+        await this.channelService.deleteById(req.params.id, req.user?.id as string);
         res.status(StatusCodes.OK).json({
             message: this.localeService.i18n().CHANNEL.DELETE_CHANNEL_SUCCESS(),
         });
     })
 
-    public deleteMultipleChannel = catchAsync(async (req, res) => {
-        await this.channelService.deleteByIds(req.body.id);
+    public deleteMultipleChannel = catchAsync(async (req: RequestWithUser, res) => {
+        await this.channelService.deleteByIds(req.body.id, req.user?.id as string);
         res.status(StatusCodes.OK).json({
             message: this.localeService.i18n().CHANNEL.DELETE_MULTIPLE_CHANNELS_SUCCESS(),
         });
     })
 
-    public getChannelsPaging = catchAsync(async (req, res) => {
+    public getAllChannels = catchAsync(async (req: RequestWithUser, res) => {
         const paging = plainToClass(PagingDTO, req.query);
 
-        const data = await this.channelService.getChannelsPaging(paging);
+        const data = await this.channelService.getAllChannels(paging, req.user?.id as string);
         res.status(StatusCodes.OK).json({ data });
     })
 }

server/src/controllers/channels.controller.ts

@@ -0,0 +1,24 @@
+import { LOCALE_KEY } from "@/constants";
+import { LocaleService } from "@/i18n/ctx";
+import { WebhookService } from "@/services/webhook.service";
+import { catchAsync } from "@/utils/catch-async";
+import { StatusCodes } from "http-status-codes";
+import Container from "typedi";
+
+export class WebhookController {
+    public webhookService = Container.get(WebhookService);
+    public localeService = Container.get<LocaleService>(LOCALE_KEY);
+
+
+    public verifyWebhook = catchAsync(async (req, res) => {
+        const data = await this.webhookService.verifyWebhook(req.params.contactId as string, req, res);
+
+        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/controllers/webhook.controller.ts

@@ -60,6 +60,7 @@ export const channels = pgTable('channels', {
    active: boolean('active'),
    deleted: boolean('deleted').default(false),
    channelTypeId: text('channel_type_id').notNull(),
+   userId: text('user_id').notNull(),
    createdAt: timestamp('created_at').defaultNow(),
    updatedAt: timestamp('updated_at'),
 });
@@ -73,6 +74,10 @@ export const channelsRelations = relations(channels, ({ one }) => ({
       fields: [channels.channelTypeId],
       references: [channelTypes.id],
    }),
+   User: one(users, {
+      fields: [channels.userId],
+      references: [users.id],
+   }),
 }));
 
 export const settings = pgTable('settings', {
@@ -84,17 +89,21 @@ export const settings = pgTable('settings', {
    email: json('email')
       .notNull()
       .default({
-         'email': '',
-         'password': '',
-      }).$type<{
+         email: '',
+         password: '',
+      })
+      .$type<{
          email: string;
          password: string;
       }>(),
    userId: varchar('user_id', {
       length: MAX_ID_LENGTH,
-   }).notNull().references(() => users.id),
+   })
+      .notNull()
+      .references(() => users.id),
 });
 
-export const usersRelations = relations(users, ({ one }) => ({
+export const usersRelations = relations(users, ({ one, many }) => ({
    settings: one(settings),
+   channels: many(channels),
 }));

server/src/database/schema.ts

@@ -19,7 +19,7 @@ async function seedChannelTypes() {
 async function seedDefaultAccount() {
     try {
         const hashedPassword = await bcrypt.hash("Hello@123", 10);
-        await db.insert(users).values({email: "[email protected]", password: hashedPassword, name: "admin",});
+        await db.insert(users).values({ email: "[email protected]", password: hashedPassword, name: "admin", });
     } catch (error) {
         console.error(`Can't create default account`);
     }