Refactor(hyunsoo/chat): 채팅방 생성 로직 수정(chat-users엔티티 추가) modern-agile-t…

…eam#92
Kimsoo0119 · Oct 20, 2022 · a19bb1e · a19bb1e
1 parent 48961f4
commit a19bb1e
Show file tree

Hide file tree

Showing 11 changed files with 167 additions and 52 deletions.
diff --git a/main-project/src/chats/chats.gateway.ts b/main-project/src/chats/chats.gateway.ts
@@ -8,7 +8,12 @@ import {
 } from '@nestjs/websockets';
 import { Namespace, Socket } from 'socket.io';
 import { ChatService } from './chats.service';
-import { MessagePayload } from './interface/chat.interface';
+import {
+  ChatRoom,
+  CreateChat,
+  JoinChatRoom,
+  MessagePayload,
+} from './interface/chat.interface';
 
 const { initializeApp, cert } = require('firebase-admin/app');
 const { getFirestore } = require('firebase-admin/firestore');
@@ -57,12 +62,24 @@ export class ChatsGateway {
   @SubscribeMessage('create-room')
   async handelCreateRoom(
     @ConnectedSocket() socket: Socket,
-    @MessageBody() messagePayload: MessagePayload,
+    @MessageBody() messagePayload: CreateChat,
   ) {
-    await this.chatService.createRoom(socket, messagePayload);
-    return { success: true };
+    try {
+      await this.chatService.createRoom(socket, messagePayload);
+    } catch (err) {
+      throw err;
+    }
   }
 
+  // @SubscribeMessage('join-room')
+  // async handelJoinRoom(
+  //   @ConnectedSocket() socket: Socket,
+  //   @MessageBody() messagePayload: JoinChatRoom,
+  // ) {
+  //   await this.chatService.joinRoom(socket, messagePayload);
+  //   return { success: true };
+  // }
+
   @SubscribeMessage('ClientToServer')
   async handelMessage(
     @ConnectedSocket() socket: Socket,

diff --git a/main-project/src/chats/chats.module.ts b/main-project/src/chats/chats.module.ts
@@ -5,10 +5,12 @@ import { MeetingRepository } from 'src/meetings/repository/meeting.repository';
 import { ChatsGateway } from './chats.gateway';
 import { ChatService } from './chats.service';
 import { ChatListRepository } from './repository/chat-list.repository';
+import { ChatUsersRepository } from './repository/chat-users.repository';
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       ChatListRepository,
+      ChatUsersRepository,
       MeetingRepository,
       MeetingInfoRepository,
     ]),

diff --git a/main-project/src/chats/chats.service.ts b/main-project/src/chats/chats.service.ts
@@ -8,22 +8,27 @@ import { MeetingInfoRepository } from 'src/meetings/repository/meeting-info.repo
 import { MeetingRepository } from 'src/meetings/repository/meeting.repository';
 import { ChatRoom, CreateChat } from './interface/chat.interface';
 import { ChatListRepository } from './repository/chat-list.repository';
+import { ChatUsersRepository } from './repository/chat-users.repository';
 
 @Injectable()
 export class ChatService {
   constructor(
     @InjectRepository(ChatListRepository)
     private readonly chatListRepository: ChatListRepository,
 
+    @InjectRepository(ChatUsersRepository)
+    private readonly chatUsersRepository: ChatUsersRepository,
+
     @InjectRepository(MeetingRepository)
     private readonly meetingRepository: MeetingRepository,
 
     @InjectRepository(MeetingInfoRepository)
     private readonly meetingInfoRepository: MeetingInfoRepository,
   ) {}
-  async createRoom(socket, chat: CreateChat) {
+
+  async createRoom(socket, chat: CreateChat): Promise<void> {
     try {
-      const { userNo, meetingNo } = chat;
+      const { meetingNo } = chat;
 
       const meetingExist = await this.meetingRepository.findMeetingById(
         meetingNo,
@@ -40,45 +45,89 @@ export class ChatService {
       }
 
       if (meetingExist && !roomExist) {
-        const { roomName } = await this.getUserNicknameByMeetingNo(meetingNo);
+        const { roomName, userNo } = await this.getUserByMeetingNo(meetingNo);
         if (!roomName) {
           throw new NotFoundException('Meeting 정보 조회 오류입니다.');
         }
-        console.log(roomName);
 
-        const result = await this.createRoomByMeetingNo({
-          userNo,
+        const userNoList: number[] = userNo.split(',').map((item) => {
+          return parseInt(item);
+        });
+
+        const chatRoomNo: number = await this.createRoomByMeetingNo({
           meetingNo,
           roomName,
         });
-        if (!result) {
+        if (!chatRoomNo) {
           throw new BadRequestException('채팅방 생성 오류입니다.');
         }
+
+        const roomUsers: object[] = userNoList.reduce((values, userNo) => {
+          values.push({ chatRoomNo, userNo });
+          return values;
+        }, []);
+
+        const result = await this.setRoomUsers(roomUsers);
+        if (!result) {
+          throw new BadRequestException('채팅방 유저정보 생성 오류입니다.');
+        }
+
         socket.join(roomName);
       }
     } catch (err) {
       throw err;
     }
   }
 
-  private async getUserNicknameByMeetingNo(meetingNo): Promise<ChatRoom> {
+  // async joinRoom(socket, chat: CreateChat) {
+  //   try {
+  //     //1. 미팅넘버로 채팅방 조회
+  //     //2. 있으면 거기서 유저 조회 후 있으면 조인
+  //     //3. 없으면 리턴
+  //     const { userNo, meetingNo } = chat;
+  //     const roomExist = await this.chatListRepository.checkRoomExist(meetingNo);
+  //     const userExist = await this.chatListRepository.isUserInChatRoom(
+  //       meetingNo,
+  //       userNo,
+  //     );
+  //   } catch (err) {
+  //     throw err;
+  //   }
+  // }
+
+  private async getUserByMeetingNo(meetingNo): Promise<ChatRoom> {
     try {
       const chatRoom: ChatRoom =
-        await this.meetingInfoRepository.getMeetingUserNickname(meetingNo);
+        await this.meetingInfoRepository.getMeetingUser(meetingNo);
       chatRoom.roomName =
         chatRoom.guestUserNickname + ',' + chatRoom.hostUserNickname;
-      console.log(chatRoom);
+      chatRoom.userNo = chatRoom.guestUserNo + ',' + chatRoom.hostUserNo;
 
       return chatRoom;
     } catch (err) {
       throw err;
     }
   }
 
-  private async createRoomByMeetingNo(createChat: CreateChat) {
+  private async setRoomUsers(roomUsers): Promise<number> {
     try {
-      const raw = await this.chatListRepository.createRoom(createChat);
-      return raw.affectedRows;
+      const affectedRows: number = await this.chatUsersRepository.setRoomUsers(
+        roomUsers,
+      );
+
+      return affectedRows;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  private async createRoomByMeetingNo(createChat: CreateChat): Promise<number> {
+    try {
+      const insertId: number = await this.chatListRepository.createRoom(
+        createChat,
+      );
+
+      return insertId;
     } catch (err) {
       throw err;
     }

diff --git a/main-project/src/chats/entity/chat-list.entity.ts b/main-project/src/chats/entity/chat-list.entity.ts
@@ -7,7 +7,9 @@ import {
   JoinColumn,
   ManyToOne,
   PrimaryGeneratedColumn,
+  OneToMany,
 } from 'typeorm';
+import { ChatUsers } from './chat-users.entity';
 
 @Entity('chat_list')
 export class ChatList extends BaseEntity {
@@ -17,11 +19,12 @@ export class ChatList extends BaseEntity {
   @Column({ name: 'room_name', type: 'varchar', length: 255, nullable: false })
   roomName: string;
 
-  @ManyToOne((type) => Users, (user) => user.chatUserNo)
-  @JoinColumn({ name: 'user_no' })
-  userNo: number;
-
-  @ManyToOne((type) => Meetings, (meeting) => meeting.chatMeetingNo)
+  @ManyToOne((type) => Meetings, (meeting) => meeting.chatMeetingNo, {
+    onDelete: 'CASCADE',
+  })
   @JoinColumn({ name: 'meeting_no' })
   meetingNo: number;
+
+  @OneToMany((type) => ChatUsers, (chatUsers) => chatUsers.chatRoomNo)
+  chatRoomNo: ChatUsers[];
 }
diff --git a/main-project/src/chats/entity/chat-users.entity.ts b/main-project/src/chats/entity/chat-users.entity.ts
@@ -0,0 +1,26 @@
+import { Users } from 'src/users/entity/user.entity';
+import {
+  BaseEntity,
+  Column,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import { ChatList } from './chat-list.entity';
+
+@Entity('chat_users')
+export class ChatUsers extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  no: number;
+
+  @ManyToOne((type) => ChatList, (chatRoom) => chatRoom.chatRoomNo, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'chat_room_no' })
+  chatRoomNo: number;
+
+  @ManyToOne((type) => Users, (user) => user.chatUserNo)
+  @JoinColumn({ name: 'user_no' })
+  userNo: number;
+}
diff --git a/main-project/src/chats/interface/chat.interface.ts b/main-project/src/chats/interface/chat.interface.ts
@@ -1,11 +1,15 @@
 export interface CreateChat {
+  userNo?: number;
+  meetingNo: number;
+  roomName?: string;
+}
+
+export interface JoinChatRoom {
   userNo: number;
   meetingNo: number;
-  roomName: string;
 }
 
 export interface MessagePayload {
-  roomName: string;
   message?: string;
   meetingNo: number;
   userNo: number;
@@ -15,4 +19,7 @@ export interface ChatRoom {
   guestUserNickname: string;
   hostUserNickname: string;
   roomName?: string;
+  userNo?: string;
+  guestUserNo?: number;
+  hostUserNo?: number;
 }
diff --git a/main-project/src/chats/repository/chat-list.repository.ts b/main-project/src/chats/repository/chat-list.repository.ts
@@ -6,7 +6,7 @@ import { ChatRoom, CreateChat } from '../interface/chat.interface';
 
 @EntityRepository(ChatList)
 export class ChatListRepository extends Repository<ChatList> {
-  async checkRoomExist(meetingNo) {
+  async checkRoomExist(meetingNo): Promise<ChatList> {
     try {
       const result = await this.createQueryBuilder('chat_list')
         .select(['chat_list.meeting_no AS meetingNo'])
@@ -21,37 +21,32 @@ export class ChatListRepository extends Repository<ChatList> {
     }
   }
 
-  async getHostUserNickname(meetingNo) {
-    try {
-      const nickname = await this.createQueryBuilder('chat_list')
-        .leftJoin('chat_list.meetingNo', 'meetingNo')
-        .leftJoin('meetingNo.hostMembers', 'hostMembers')
-        .leftJoin('hostMembers.userNo', 'hostUserNo')
-        .select([
-          'chat_list.room_name AS roomName',
-          'hostUserNo.nickname AS hostUserNickname',
-          // 'guestUserNo.nickname AS guestUserNickname',
-        ])
-        .where('chat_list.meeting_no = :meetingNo', { meetingNo })
-        .getRawMany();
-
-      return nickname;
-    } catch (err) {
-      throw err;
-    }
-  }
-
-  async createRoom(createChat: CreateChat) {
+  async createRoom(createChat: CreateChat): Promise<number> {
     try {
       const { raw }: InsertResult = await this.createQueryBuilder('chat_list')
         .insert()
         .into(ChatList)
         .values(createChat)
         .execute();
 
-      return raw;
+      return raw.insertId;
     } catch (err) {
       throw new InternalServerErrorException(`${err}`);
     }
   }
+
+  // async isUserInChatRoom(meetingNo, userNo) {
+  //   try {
+  //     // const result = await this.createQueryBuilder('chat_list')
+  //     //   .select(['chat_list.meeting_no AS meetingNo',])
+  //     //   .where(`meeting_no = :meetingNo`, { meetingNo })
+  //     //   .andWhere()
+  //     //   .getRawOne();
+  //     // return result;
+  //   } catch (err) {
+  //     throw new InternalServerErrorException(
+  //       `${err}: 채팅방 중복 확인 (checkRoomExist): 알 수 없는 서버 에러입니다.`,
+  //     );
+  //   }
+  // }
 }
diff --git a/main-project/src/chats/repository/chat-users.repository.ts b/main-project/src/chats/repository/chat-users.repository.ts
@@ -0,0 +1,15 @@
+import { EntityRepository, InsertResult, Repository } from 'typeorm';
+import { ChatUsers } from '../entity/chat-users.entity';
+
+@EntityRepository(ChatUsers)
+export class ChatUsersRepository extends Repository<ChatUsers> {
+  async setRoomUsers(roomUsers): Promise<number> {
+    const { raw }: InsertResult = await this.createQueryBuilder('chat_users')
+      .insert()
+      .into(ChatUsers)
+      .values(roomUsers)
+      .execute();
+
+    return raw.affectedRows;
+  }
+}
diff --git a/main-project/src/meetings/repository/meeting-info.repository.ts b/main-project/src/meetings/repository/meeting-info.repository.ts
@@ -70,7 +70,7 @@ export class MeetingInfoRepository extends Repository<MeetingInfo> {
     }
   }
 
-  async getMeetingUserNickname(meetingNo): Promise<ChatRoom> {
+  async getMeetingUser(meetingNo): Promise<ChatRoom> {
     try {
       const nickname = await this.createQueryBuilder('meeting_info')
         .leftJoin('meeting_info.meetingNo', 'meetingNo')
@@ -81,6 +81,8 @@ export class MeetingInfoRepository extends Repository<MeetingInfo> {
         .select([
           'GROUP_CONCAT(DISTINCT guestUserNo.nickname) AS guestUserNickname',
           'GROUP_CONCAT(DISTINCT hostUserNo.nickname) AS hostUserNickname',
+          'GROUP_CONCAT(DISTINCT hostMembers.user_no) AS hostUserNo',
+          'GROUP_CONCAT(DISTINCT guestMembers.user_no) AS guestUserNo',
         ])
         .where('meeting_info.meetingNo = :meetingNo', { meetingNo })
         .getRawOne();

diff --git a/main-project/src/meetings/repository/meeting.repository.ts b/main-project/src/meetings/repository/meeting.repository.ts
@@ -34,8 +34,6 @@ export class MeetingRepository extends Repository<Meetings> {
 
   async findMeetingById(meetingNo: number): Promise<Meetings> {
     try {
-      console.log(meetingNo);
-
       const meeting: Meetings = await this.createQueryBuilder('meetings')
         .where('meetings.no = :meetingNo', { meetingNo })
         .getOne();

diff --git a/main-project/src/users/entity/user.entity.ts b/main-project/src/users/entity/user.entity.ts
@@ -1,6 +1,7 @@
 import { BoardBookmarks } from 'src/boards/entity/board-bookmark.entity';
 import { Boards } from 'src/boards/entity/board.entity';
 import { ChatList } from 'src/chats/entity/chat-list.entity';
+import { ChatUsers } from 'src/chats/entity/chat-users.entity';
 import { Enquiries } from 'src/enquiries/entity/enquiry.entity';
 import { Friends } from 'src/friends/entity/friend.entity';
 import { MeetingInfo } from 'src/meetings/entity/meeting-info.entity';
@@ -88,6 +89,6 @@ export class Users extends BaseEntity {
   @OneToOne((type) => UserProfile, (userProfile) => userProfile.userNo)
   userProfileNo: UserProfile;
 
-  @OneToMany((type) => ChatList, (chatList) => chatList.userNo)
-  chatUserNo: ChatList[];
+  @OneToMany((type) => ChatUsers, (chatUsers) => chatUsers.userNo)
+  chatUserNo: ChatUsers[];
 }