Add(hyunsoo/chat): 채팅 로그 엔티티 추가 modern-agile-team#92

main-project/src/chats/chats.gateway.ts

@@ -22,8 +22,8 @@ export class ChatsGateway {
 
   @WebSocketServer() nsp: Namespace;
   afterInit() {
-    this.nsp.adapter.on('create-room', (room) => {
-      this.logger.log(`"Room:${room}"이 생성되었습니다.`);
+    this.nsp.adapter.on('init-socket', (room, id) => {
+      this.logger.log(`"Socket:${id}"초기화 되었습니다.`);
     });
 
     this.nsp.adapter.on('join-room', (room, id) => {
@@ -49,13 +49,27 @@ export class ChatsGateway {
     this.logger.log(`${socket.id} 소켓연결 해제`);
   }
 
+  @SubscribeMessage('init-socket')
+  async handelInitSocket(
+    @ConnectedSocket() socket: Socket,
+    @MessageBody() userNo: number,
+  ) {
+    try {
+      await this.chatService.initSocket(socket, userNo);
+    } catch (err) {
+      throw err;
+    }
+  }
+
   @SubscribeMessage('create-room')
   async handelCreateRoom(
     @ConnectedSocket() socket: Socket,
     @MessageBody() messagePayload: CreateChat,
   ) {
     try {
       await this.chatService.createRoom(socket, messagePayload);
+
+      return { success: true };
     } catch (err) {
       throw err;
     }

main-project/src/chats/chats.module.ts

@@ -7,13 +7,15 @@ import { ChatService } from './chats.service';
 import { ChatListRepository } from './repository/chat-list.repository';
 import { ChatUsersRepository } from './repository/chat-users.repository';
 import { ChatsController } from './chats.controller';
+import { ChatLogRepository } from './repository/chat-log.repository';
 @Module({
   imports: [
     TypeOrmModule.forFeature([
       ChatListRepository,
       ChatUsersRepository,
       MeetingRepository,
       MeetingInfoRepository,
+      ChatLogRepository,
     ]),
   ],
   providers: [ChatsGateway, ChatService],

main-project/src/chats/chats.service.ts

@@ -8,6 +8,7 @@ import { MeetingInfoRepository } from 'src/meetings/repository/meeting-info.repo
 import { MeetingRepository } from 'src/meetings/repository/meeting.repository';
 import {
   ChatRoom,
+  ChatRoomList,
   ChatRoomUsers,
   CreateChat,
   JoinChatRoom,
@@ -32,6 +33,21 @@ export class ChatService {
     private readonly meetingInfoRepository: MeetingInfoRepository,
   ) {}
 
+  async initSocket(socket, userNo: number): Promise<void> {
+    try {
+      const chatRoomList = await this.getChatRoomListByUserNo(
+        Object.values(userNo),
+      );
+      if (chatRoomList) {
+        chatRoomList.forEach((el) => {
+          socket.join(`${el.chatRoomNo}`);
+        });
+      }
+    } catch (err) {
+      throw err;
+    }
+  }
+
   async createRoom(socket, chat: CreateChat): Promise<void> {
     try {
       const { meetingNo } = chat;
@@ -50,36 +66,34 @@ export class ChatService {
         throw new BadRequestException('이미 생성된 채팅방 입니다.');
       }
 
-      if (meetingExist && !roomExist) {
-        const { roomName, userNo } = await this.getUserByMeetingNo(meetingNo);
-        if (!roomName) {
-          throw new NotFoundException('Meeting 정보 조회 오류입니다.');
-        }
-
-        const userNoList: number[] = userNo.split(',').map((item) => {
-          return parseInt(item);
-        });
+      const { roomName, userNo } = await this.getUserByMeetingNo(meetingNo);
+      if (!roomName) {
+        throw new NotFoundException('Meeting 정보 조회 오류입니다.');
+      }
 
-        const chatRoomNo: number = await this.createRoomByMeetingNo({
-          meetingNo,
-          roomName,
-        });
-        if (!chatRoomNo) {
-          throw new BadRequestException('채팅방 생성 오류입니다.');
-        }
+      const userNoList: number[] = userNo.split(',').map((item) => {
+        return parseInt(item);
+      });
 
-        const roomUsers: object[] = userNoList.reduce((values, userNo) => {
-          values.push({ chatRoomNo, userNo });
-          return values;
-        }, []);
+      const chatRoomNo: number = await this.createRoomByMeetingNo({
+        meetingNo,
+        roomName,
+      });
+      if (!chatRoomNo) {
+        throw new BadRequestException('채팅방 생성 오류입니다.');
+      }
 
-        const result = await this.setRoomUsers(roomUsers);
-        if (!result) {
-          throw new BadRequestException('채팅방 유저정보 생성 오류입니다.');
-        }
+      const roomUsers: object[] = userNoList.reduce((values, userNo) => {
+        values.push({ chatRoomNo, userNo });
+        return values;
+      }, []);
 
-        socket.join(`${chatRoomNo}`);
+      const result = await this.setRoomUsers(roomUsers);
+      if (!result) {
+        throw new BadRequestException('채팅방 유저정보 생성 오류입니다.');
       }
+
+      socket.join(`${chatRoomNo}`);
     } catch (err) {
       throw err;
     }
@@ -105,12 +119,14 @@ export class ChatService {
     }
   }
 
-  async getChatRoomListByUserNo(userNo) {
+  async getChatRoomListByUserNo(userNo): Promise<ChatRoomList[]> {
     try {
-      const chatList = await this.chatUsersRepository.getChatRoomList(userNo);
+      const chatList: ChatRoomList[] =
+        await this.chatUsersRepository.getChatRoomList(userNo);
       if (!chatList.length) {
         throw new BadRequestException('채팅방이 존재하지 않습니다.');
       }
+
       return chatList;
     } catch (err) {
       throw err;
@@ -129,6 +145,7 @@ export class ChatService {
       socket.broadcast.to(`${chatRoomNo}`).emit('message', {
         message,
         userNo,
+        chatRoomNo,
       });
     } catch (err) {
       throw err;

main-project/src/chats/entity/chat-list.entity.ts

@@ -9,6 +9,7 @@ import {
   PrimaryGeneratedColumn,
   OneToMany,
 } from 'typeorm';
+import { ChatLog } from './chat-log.entity';
 import { ChatUsers } from './chat-users.entity';
 
 @Entity('chat_list')
@@ -27,4 +28,7 @@ export class ChatList extends BaseEntity {
 
   @OneToMany((type) => ChatUsers, (chatUsers) => chatUsers.chatRoomNo)
   chatUserNo: ChatUsers[];
+
+  @OneToMany((type) => ChatLog, (chatLog) => chatLog.chatRoomNo)
+  chatLogNo: ChatLog[];
 }

main-project/src/chats/entity/chat-log.entity.ts

@@ -0,0 +1,32 @@
+import { Users } from 'src/users/entity/user.entity';
+import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+} from 'typeorm';
+import { ChatList } from './chat-list.entity';
+
+@Entity('chat_log')
+export class ChatLog extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  no: number;
+
+  @ManyToOne((type) => ChatList, (chatList) => chatList.chatLogNo)
+  @JoinColumn({ name: 'chat_room_no' })
+  chatRoomNo: number;
+
+  @ManyToOne((type) => Users, (users) => users.chatLogUserNo)
+  @JoinColumn({ name: 'user_no' })
+  userNo: number;
+
+  @Column()
+  message: string;
+
+  @CreateDateColumn({ name: 'sended_time' })
+  sendedTime: Date;
+}

main-project/src/chats/interface/chat.interface.ts

@@ -31,3 +31,8 @@ export interface ChatRoomUsers {
   meetingNo: number;
   userNo: number;
 }
+
+export interface ChatRoomList {
+  roomName: string;
+  chatRoomNo: number;
+}

main-project/src/chats/repository/chat-log.repository.ts

@@ -0,0 +1,5 @@
+import { EntityRepository, Repository } from 'typeorm';
+import { ChatLog } from '../entity/chat-log.entity';
+
+@EntityRepository(ChatLog)
+export class ChatLogRepository extends Repository<ChatLog> {}

main-project/src/chats/repository/chat-users.repository.ts

@@ -1,6 +1,7 @@
 import { InternalServerErrorException } from '@nestjs/common';
 import { EntityRepository, InsertResult, Repository } from 'typeorm';
 import { ChatUsers } from '../entity/chat-users.entity';
+import { ChatRoomList } from '../interface/chat.interface';
 
 @EntityRepository(ChatUsers)
 export class ChatUsersRepository extends Repository<ChatUsers> {
@@ -20,13 +21,13 @@ export class ChatUsersRepository extends Repository<ChatUsers> {
     }
   }
 
-  async getChatRoomList(userNo: number) {
+  async getChatRoomList(userNo: number): Promise<ChatRoomList[]> {
     try {
       const chatRoomList = await this.createQueryBuilder('chat_users')
         .leftJoin('chat_users.chatRoomNo', 'chatRoomNo')
         .select([
           'chatRoomNo.room_name AS roomName',
-          'chat_users.no AS chatRoomNo',
+          'chat_users.chat_room_no AS chatRoomNo',
         ])
         .where('chat_users.user_no = :userNo', { userNo })
         .getRawMany();

main-project/src/common/configs/typeorm.config.ts

@@ -10,7 +10,7 @@ export const typeOrmConfig: TypeOrmModuleAsyncOptions = {
     username: configService.get<string>('DB_USERNAME'),
     password: configService.get<string>('DB_PASSWORD'),
     database: configService.get<string>('DB_DATABASE'),
-    synchronize: false,
+    synchronize: true,
     entities: [__dirname + '/../../**/entity/*.entity.{js,ts}'],
     logging: true,
   }),

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 { ChatLog } from 'src/chats/entity/chat-log.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';
@@ -95,4 +96,7 @@ export class Users extends BaseEntity {
 
   @OneToMany((type) => NoticeGuests, (noticeGuests) => noticeGuests.userNo)
   noticeGuests: NoticeGuests[];
+
+  @OneToMany((type) => ChatLog, (chatLog) => chatLog.userNo)
+  chatLogUserNo: ChatLog[];
 }