feat: add grade from Use ratings for flat AI room

Author: hqer927

src/model/room/RoomUser.ts

@@ -29,6 +29,12 @@ export class RoomUserModel extends Content {
     })
     rtc_uid: string;
 
+    @Column({
+        default: -1,
+        type: "int",
+    })
+    grade: number;
+
     @Index("room_users_is_delete_index")
     @Column({
         default: false,

src/v1/controller/agora/Router.ts

@@ -3,10 +3,16 @@ import { GenerateRTM } from "./token/RTM";
 import { ControllerClass } from "../../../abstract/controller";
 import { MessageCallback } from "./message/Callback";
 import { RTMCensor } from "./rtm/censor";
+import { AgoraAIPing } from "./ai/ping";
+import { AgoraAIStart } from "./ai/start";
+import { AgoraAIStop } from "./ai/stop";
 
 export const agoraRouters: Readonly<Array<ControllerClass<any, any>>> = Object.freeze([
     GenerateRTC,
     GenerateRTM,
     MessageCallback,
     RTMCensor,
+    AgoraAIPing,
+    AgoraAIStart,
+    AgoraAIStop
 ]);

src/v1/controller/agora/ai/const.ts

@@ -0,0 +1 @@
+export const AI_SERVER_URL = "http://106.13.114.185:8081";

src/v1/controller/agora/ai/ping.ts

@@ -0,0 +1,55 @@
+import { FastifySchema, Response, ResponseError } from "../../../../types/Server";
+import { ax } from "../../../utils/Axios";
+import { AbstractController } from "../../../../abstract/controller";
+import { Controller } from "../../../../decorator/Controller";
+import { AI_SERVER_URL } from "./const";
+
+@Controller<RequestType, any>({
+    method: "post",
+    path: "agora/ai/ping",
+    auth: true,
+})
+export class AgoraAIPing extends AbstractController<RequestType, any> {
+    public static readonly schema: FastifySchema<RequestType> = {
+        body: {
+            type: "object",
+            required: ["request_id", "channel_name"],
+            properties: {
+                request_id: {
+                    type: "string",
+                },
+                channel_name: {
+                    type: "string",
+                },
+            },
+        },
+    };
+
+    public async execute(): Promise<Response<any>> {
+        const { request_id, channel_name  } = this.body;
+
+        const res = await ax.post<any>(`${AI_SERVER_URL}/ping`, {
+                request_id, 
+                channel_name
+            }, 
+            {    
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            }
+        )
+        return res;
+
+    }
+
+    public errorHandler(error: Error): ResponseError {
+        return this.autoHandlerError(error);
+    }
+}
+
+interface RequestType {
+    body: {
+        request_id: string;
+        channel_name: string;
+    };
+}

src/v1/controller/agora/ai/start.ts

@@ -0,0 +1,71 @@
+import { FastifySchema, Response, ResponseError } from "../../../../types/Server";
+import { ax } from "../../../utils/Axios";
+import { AbstractController } from "../../../../abstract/controller";
+import { Controller } from "../../../../decorator/Controller";
+import { AI_SERVER_URL } from "./const";
+
+@Controller<RequestType, any>({
+    method: "post",
+    path: "agora/ai/start",
+    auth: true,
+})
+export class AgoraAIStart extends AbstractController<RequestType, any> {
+    public static readonly schema: FastifySchema<RequestType> = {
+        body: {
+            type: "object",
+            required: ["request_id", "channel_name", "user_uid", "language", "scene", "role"],
+            properties: {
+                request_id: {
+                    type: "string",
+                },
+                channel_name: {
+                    type: "string",
+                },
+                user_uid: {
+                    type: "string",
+                },
+                language: {
+                    type: "string",
+                },
+                scene: {
+                    type: "string",
+                },
+                role: {
+                    type: "string",
+                },
+            },
+        },
+    };
+
+    public async execute(): Promise<Response<any>> {
+        const { request_id, channel_name, user_uid  } = this.body;
+
+        const res = await ax.post<any>(`${AI_SERVER_URL}/start`, {
+                request_id, 
+                channel_name,
+                user_uid,
+            }, 
+            {    
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            }
+        )
+        return res;
+    }
+
+    public errorHandler(error: Error): ResponseError {
+        return this.autoHandlerError(error);
+    }
+}
+
+interface RequestType {
+    body: {
+        request_id: string;
+        channel_name: string;
+        user_uid: string;
+        language: string;
+        scene: string;
+        role: string;
+    };
+}

src/v1/controller/agora/ai/stop.ts

@@ -0,0 +1,54 @@
+import { FastifySchema, Response, ResponseError } from "../../../../types/Server";
+import { ax } from "../../../utils/Axios";
+import { AbstractController } from "../../../../abstract/controller";
+import { Controller } from "../../../../decorator/Controller";
+import { AI_SERVER_URL } from "./const";
+
+@Controller<RequestType, any>({
+    method: "post",
+    path: "agora/ai/stop",
+    auth: true,
+})
+export class AgoraAIStop extends AbstractController<RequestType, any> {
+    public static readonly schema: FastifySchema<RequestType> = {
+        body: {
+            type: "object",
+            required: ["request_id", "channel_name"],
+            properties: {
+                request_id: {
+                    type: "string",
+                },
+                channel_name: {
+                    type: "string",
+                },
+            },
+        },
+    };
+
+    public async execute(): Promise<Response<any>> {
+        const { request_id, channel_name  } = this.body;
+
+        const res = await ax.post<any>(`${AI_SERVER_URL}/start`, {
+                request_id, 
+                channel_name,
+            }, 
+            {    
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            }
+        )
+        return res;
+    }
+
+    public errorHandler(error: Error): ResponseError {
+        return this.autoHandlerError(error);
+    }
+}
+
+interface RequestType {
+    body: {
+        request_id: string;
+        channel_name: string;
+    };
+}

src/v1/controller/room/grade/Get.ts

@@ -0,0 +1,66 @@
+import { FastifySchema, Response, ResponseError } from "../../../../types/Server";
+import { Status } from "../../../../constants/Project";
+import { ErrorCode } from "../../../../ErrorCode";
+import { RoomUserDAO } from "../../../../dao";
+import { Controller } from "../../../../decorator/Controller";
+import { AbstractController } from "../../../../abstract/controller";
+
+@Controller<RequestType, ResponseType>({
+    method: "post",
+    path: "user/grade/get",
+    auth: true,
+})
+export class GetGrade extends AbstractController<RequestType, ResponseType> {
+    public static readonly schema: FastifySchema<RequestType> = {
+        body: {
+            type: "object",
+            required: ["roomUUID", "userUUID"],
+            properties: {
+                roomUUID: {
+                    type: "string",
+                },
+                userUUID: {
+                    type: "string",
+                }
+            },
+        },
+    };
+
+    public async execute(): Promise<Response<any>> {
+        const { roomUUID, userUUID } = this.body;
+
+        const roomUserInfo = await RoomUserDAO().findOne(["grade"], {
+            user_uuid: userUUID,
+            room_uuid: roomUUID,
+        });
+        
+        if (roomUserInfo === undefined) {
+            return {
+                status: Status.Failed,
+                code: ErrorCode.UserNotFound,
+            };
+        }
+        
+        return {
+            status: Status.Success,
+            data: {
+                grade: roomUserInfo.grade === -1 ? undefined : roomUserInfo.grade,
+            },
+        };
+        
+    }
+
+    public errorHandler(error: Error): ResponseError {
+        return this.autoHandlerError(error);
+    }
+}
+type ResponseType = {
+    grade?: number;
+};
+
+interface RequestType {
+    body: {
+        roomUUID: string;
+        userUUID: string;
+    };
+}

src/v1/controller/room/grade/Set.ts

@@ -0,0 +1,74 @@
+import { FastifySchema, Response, ResponseError } from "../../../../types/Server";
+import { Status } from "../../../../constants/Project";
+import { ErrorCode } from "../../../../ErrorCode";
+import { RoomUserDAO } from "../../../../dao";
+import { Controller } from "../../../../decorator/Controller";
+import { AbstractController } from "../../../../abstract/controller";
+
+@Controller<RequestType, any>({
+    method: "post",
+    path: "user/grade/set",
+    auth: true,
+})
+export class SetGrade extends AbstractController<RequestType, any> {
+    public static readonly schema: FastifySchema<RequestType> = {
+        body: {
+            type: "object",
+            required: ["roomUUID", "userUUID", "grade"],
+            properties: {
+                roomUUID: {
+                    type: "string",
+                },
+                userUUID: {
+                    type: "string",
+                },
+                grade: {
+                    type: "integer",
+                    minimum: 0,
+                    maximum: 5,
+                }
+            },
+        },
+    };
+
+    public async execute(): Promise<Response<any>> {
+        const { roomUUID, userUUID, grade } = this.body;
+
+        const roomUserInfo = await RoomUserDAO().findOne(["id"], {
+            user_uuid: userUUID,
+            room_uuid: roomUUID,
+        });
+
+        if (roomUserInfo === undefined) {
+            return {
+                status: Status.Failed,
+                code: ErrorCode.UserNotFound,
+            };
+        }
+        
+        await RoomUserDAO().update({
+            grade,
+        },{
+            room_uuid: roomUUID,
+            user_uuid: userUUID,
+        });
+
+        return {
+            status: Status.Success,
+            data: null,
+        };
+        
+    }
+
+    public errorHandler(error: Error): ResponseError {
+        return this.autoHandlerError(error);
+    }
+}
+
+interface RequestType {
+    body: {
+        roomUUID: string;
+        userUUID: string;
+        grade: number;
+    };
+}