Merge remote-tracking branch 'origin/DIAL-33-Add-API-for-botflow' into DIAL-32-ui-chat-bot

Author: hi02102002

server/src/channels/base.channel.ts

@@ -1,4 +1,5 @@
 import { BOT_ENDPOINT, PUBLIC_DOMAIN } from "@/config";
+import { logger } from "@/utils/logger";
 import axios from "axios";
 
 export class BaseChannel {
@@ -39,14 +40,10 @@ export class BaseChannel {
                 },
             })
             if (postMsg.data.success) {
-                console.log(
-                    `[${this.channelType} - ${this.contactName} ${this.contactId}] - [Conversation ID: ${uid}] - [Send message to bot - Message: ${message}] - [Data: ${data}]`
-                )
+                logger.info(`[${this.channelType}] User ${userId} 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}]`
-            );
+            logger.info(`[${this.channelType}] User ${userId} can not send message to Bot - Message: ${message} - Error: ${error.message}`);
         }
     }
 

server/src/channels/line.channel.ts

@@ -0,0 +1,102 @@
+import { PUBLIC_DOMAIN } from "@/config";
+import { logger } from "@/utils/logger";
+import axios from "axios";
+import { Request, Response } from "express";
+import { BaseChannel } from "./base.channel";
+
+export class LineChannel extends BaseChannel {
+    pageToken: string;
+    linePostURL: string;
+    credentials: string;
+
+    constructor(id: string, contactId: string, contactName: string, channelType: string, credentials: string) {
+        super(id, contactId, contactName, channelType);
+
+        let parseCredentials: LineChannel;
+
+        this.credentials = credentials;
+
+        if (credentials && typeof credentials == 'string') parseCredentials = JSON.parse(credentials);
+
+        if (parseCredentials) {
+            this.pageToken = parseCredentials.pageToken;
+        }
+
+        this.channelType = channelType;
+        this.linePostURL = `https://api.line.me/v2/bot`;
+    }
+
+    public async registerWebhook() {
+        try {
+            await axios({
+                method: 'PUT',
+                url: this.linePostURL + '/channel/webhook/endpoint',
+                data: { endpoint: PUBLIC_DOMAIN + '/webhook/' + this.contactId },
+                headers: {
+                    Authorization: `Bearer ${this.pageToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            logger.info(`[LIN] Registered webhook for ${this.channelType} - ${this.contactName} ${this.contactId}`);
+        } catch (e) {
+            logger.info(`[LIN] Can not register webhook for ${this.channelType} - ${this.contactName} ${this.contactId}`);
+
+        }
+    }
+
+    async getLineUserID() {
+        try {
+            const { data } = await axios({
+                method: 'GET',
+                url: this.linePostURL + '/info',
+                headers: {
+                    Authorization: `Bearer ${this.pageToken}`,
+                },
+            });
+            if (!data || !data.userId) throw new Error();
+
+            return data.userId;
+        } catch (e) {
+            logger.info(`[LIN] Can not get user ID for ${this.channelType} - ${this.contactName} ${this.contactId}`);
+        }
+    }
+
+    async prepareMessage(req: Request, res: Response) {
+        try {
+            const { destination, events } = req.body;
+
+            if (!(events && events[0] && events[0].type == 'message')) return;
+
+            const lineUserId = await this.getLineUserID();
+
+            if (destination == lineUserId) {
+                const { message, source } = events[0];
+
+                await this.postMessageToBot({ userId: source.userId, message: message.text, data: null });
+            }
+        } catch (e) { }
+    }
+
+    public async sendMessageToUser({ userId, text }) {
+        const lineUserId = await this.getLineUserID();
+        try {
+            if (!text) return;
+
+            await axios({
+                method: 'POST',
+                url: this.linePostURL + '/message/push',
+                data: {
+                    to: userId,
+                    messages: [{ type: 'text', text }],
+                },
+                headers: {
+                    Authorization: 'Bearer ' + this.pageToken,
+                },
+            })
+
+            logger.info(`[LIN] Bot send message to User ${lineUserId} - Message: ${text}`);
+        } catch (e) {
+            logger.info(`[LIN] Bot send message to User ${lineUserId} failed - Error: ${e.message}`);
+        }
+    }
+}

server/src/channels/messenger.channel.ts

@@ -1,4 +1,6 @@
 import { Helper } from "@/utils/helper";
+import { logger } from "@/utils/logger";
+import axios from "axios";
 import { Request, Response } from "express";
 import { BaseChannel } from "./base.channel";
 
@@ -32,10 +34,10 @@ export class MessengerChannel extends BaseChannel {
         let challenge = req.query['hub.challenge'];
 
         if (mode === 'subscribe' && this.webhookSecret == token) {
-            console.log(`channel ${this.channelType} - ${this.contactName} ${this.contactId} webhook verified!`);
+            logger.info(`[MSG] channel ${this.channelType} - ${this.contactName} ${this.contactId} webhook verified!`);
             return challenge;
         } else {
-            console.error(`Verification channel ${this.channelType} - ${this.contactName} ${this.contactId} failed!`);
+            console.error(`[MSG] Verification channel ${this.channelType} - ${this.contactName} ${this.contactId} failed!`);
             return;
         }
     }
@@ -72,4 +74,50 @@ export class MessengerChannel extends BaseChannel {
     sendAddressToBot({ userId, address }) {
         return this.postMessageToBot({ userId, message: 'ADDRESS', data: { USER_INFORMATION: Helper.arrayToObj(address) } });
     }
+
+    public async sendMessageToUser({ userId, text }) {
+        if (!text) return;
+
+        try {
+            await axios({
+                method: 'POST',
+                url: this.messengerPostURL + this.pageToken,
+                data: {
+                    messaging_type: 'RESPONSE',
+                    recipient: {
+                        id: userId,
+                    },
+                    message: { text },
+                },
+            });
+
+            logger.info(`[MSG] Bot Sent message to User ${userId} - Message: ${text}`);
+        } catch (e) {
+            logger.info(`[MSG] Bot Sent message to User ${userId} failed - Error: ${e.message}`);
+        }
+    }
+
+    public async sendActionToUser({ userId, type }) {
+        const types = {
+            typing: 'TYPING_ON',
+        };
+
+        if (!types[type]) return;
+
+        try {
+            await axios({
+                method: 'POST',
+                url: this.messengerPostURL + this.pageToken,
+                data: {
+                    messaging_type: 'RESPONSE',
+                    recipient: {
+                        id: userId,
+                    },
+                    sender_action: types[type],
+                },
+            });
+        } catch (e) {
+            logger.info(`[MSG] Messenger can not send action to User - Error: ${e.message}`);
+        }
+    }
 }

server/src/constants/index.ts

@@ -46,6 +46,16 @@ export const ENDPOINTS = {
       VERIFY: '/webhook/:contactId',
       INCOMING_MSG: '/webhook/:contactId',
    },
+   CONVERSATION: {
+      INDEX: '/v3/conversations'
+   },
+   FLOW: {
+      INDEX: '/flow',
+      GET_ONE: '/flow/get-one',
+      PUBLISH: '/flow/publish-flow',
+      ADD_CHANNELS: '/flow/add-channels',
+      SELECT_FLOWS_FOR_CHANNEL: '/flow/select'
+   }
 };
 
 export const LOCALE_KEY = 'lang';

server/src/controllers/conversation.controller.ts

@@ -0,0 +1,17 @@
+import { LOCALE_KEY } from "@/constants";
+import { LocaleService } from "@/i18n/ctx";
+import { ConversationService } from "@/services/conversation.service";
+import { catchAsync } from "@/utils/catch-async";
+import { StatusCodes } from "http-status-codes";
+import Container from "typedi";
+
+export class ConversationController {
+    public conversationService = Container.get(ConversationService);
+    public localeService = Container.get<LocaleService>(LOCALE_KEY);
+
+    public handleIncomingMessage = catchAsync(async (req, res) => {
+        res.status(StatusCodes.OK).end();
+        return await this.conversationService.handleIncomingMessage(req);
+    });
+
+}

server/src/controllers/flows.controller.ts

@@ -0,0 +1,86 @@
+import { LOCALE_KEY } from '@/constants';
+import { PagingDTO } from '@/dtos/paging.dto';
+import { LocaleService } from '@/i18n/ctx';
+import { RequestWithUser } from '@/interfaces/auth.interface';
+import { FlowService } from '@/services/flows.service';
+import { catchAsync } from '@/utils/catch-async';
+import { plainToClass } from 'class-transformer';
+import { StatusCodes } from 'http-status-codes';
+import Container from 'typedi';
+
+export class FlowController {
+    public flowService = Container.get(FlowService);
+    public localeService = Container.get<LocaleService>(LOCALE_KEY);
+
+    public createFlow = catchAsync(async (req: RequestWithUser, res) => {
+        req.body.userId = req.user?.id;
+        await this.flowService.create(req.body);
+        res.status(StatusCodes.OK).json({
+            message: this.localeService.i18n().FLOW.CREATE_SUCCESS(),
+        });
+    });
+
+    public updateFlow = catchAsync(async (req: RequestWithUser, res) => {
+        req.body.userId = req.user?.id;
+        await this.flowService.updateFlowById(req.params.id, req.body);
+        res.status(StatusCodes.OK).json({
+            message: this.localeService.i18n().FLOW.UPDATE_SUCCESS(),
+        });
+    });
+
+    public deleteFlow = catchAsync(async (req: RequestWithUser, res) => {
+        await this.flowService.deleteById(
+            req.params.id,
+            req.user?.id as string
+        );
+        res.status(StatusCodes.OK).json({
+            message: this.localeService.i18n().FLOW.DELETE_FLOW_SUCCESS(),
+        });
+    });
+
+    public publishFlow = catchAsync(async (req: RequestWithUser, res) => {
+        await this.flowService.publishFlow(
+            req.params.id,
+            req.user?.id as string
+        )
+        res.status(StatusCodes.OK).json({
+            message: this.localeService.i18n().FLOW.PUBLISH_FLOW_SUCCESS(),
+        });
+    });
+
+    public getFlowById = catchAsync(async (req: RequestWithUser, res) => {
+        const data = await this.flowService.getFlowById(
+            req.params.id,
+            req.user?.id as string
+        )
+        res.status(StatusCodes.OK).json({ data });
+    });
+
+    public getAllFlows = catchAsync(async (req: RequestWithUser, res) => {
+        const paging = plainToClass(PagingDTO, req.query);
+
+        const data = await this.flowService.getAllFlows(
+            paging,
+            req.user?.id as string
+        );
+        res.status(StatusCodes.OK).json({ data });
+    });
+
+    public addMultipleChannels = catchAsync(async (req: RequestWithUser, res) => {
+        await this.flowService.addMultipleChannels(
+            req.body.channelIds,
+            req.body.flowId,
+            req.user?.id as string
+        );
+        res.status(StatusCodes.OK).json({
+            message: this.localeService.i18n().FLOW.ADD_MULTIPLE_CHANNELS_FLOW__SUCCESS(),
+        });
+    });
+
+    public selectFlowsForChannel = catchAsync(async (req: RequestWithUser, res) => {
+        const data = await this.flowService.selectFlowsForChannel(
+            req.user?.id as string
+        );
+        res.status(StatusCodes.OK).json({ data });
+    });
+}

server/src/controllers/webhook.controller.ts

@@ -17,8 +17,8 @@ export class WebhookController {
     });
 
     public handleIncomingMessage = catchAsync(async (req, res) => {
-        res.status(StatusCodes.OK);
 
-        return await this.webhookService.handleIncomingMessage(req.params.contactId, req, res);
+        await this.webhookService.handleIncomingMessage(req.params.contactId, req, res);
+        res.status(StatusCodes.OK).end();
     });
 }

server/src/database/migrations/0003_amused_rumiko_fujikawa.sql

@@ -0,0 +1,40 @@
+CREATE TABLE IF NOT EXISTS "flows" (
+	"id" varchar(36) PRIMARY KEY NOT NULL,
+	"name" text NOT NULL,
+	"user_id" varchar(36) NOT NULL,
+	"deleted" boolean DEFAULT false,
+	"updated_at" timestamp,
+	"created_at" timestamp DEFAULT now(),
+	"diagrams" json DEFAULT '[]'::json,
+	"edges" json DEFAULT '[]'::json,
+	"nodes" json DEFAULT '[]'::json,
+	"settings" json DEFAULT '[]'::json,
+	"variables" json DEFAULT '{}'::json,
+	"flows" json DEFAULT '[]'::json,
+	"publish_at" timestamp
+);
+--> statement-breakpoint
+ALTER TABLE "channels" ADD COLUMN "flow_id" text;--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "channels" ADD CONSTRAINT "channels_channel_type_id_channel_types_id_fk" FOREIGN KEY ("channel_type_id") REFERENCES "channel_types"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "channels" ADD CONSTRAINT "channels_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "channels" ADD CONSTRAINT "channels_flow_id_flows_id_fk" FOREIGN KEY ("flow_id") REFERENCES "flows"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;
+--> statement-breakpoint
+DO $$ BEGIN
+ ALTER TABLE "flows" ADD CONSTRAINT "flows_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE no action ON UPDATE no action;
+EXCEPTION
+ WHEN duplicate_object THEN null;
+END $$;