Merge pull request #22 from oodd-team/OD-49

Od 49

Author: happbob

package.json

@@ -28,6 +28,7 @@
     "@nestjs/swagger": "^7.4.2",
     "@nestjs/typeorm": "^10.0.2",
     "@types/passport-kakao": "^1.0.3",
+    "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "dayjs": "^1.11.13",
     "mysql2": "^3.11.0",

src/auth/auth.module.ts

@@ -20,7 +20,7 @@ import { JwtStrategy } from './strategies/jwt.strategy';
       inject: [ConfigService],
       useFactory: async (configService: ConfigService) => ({
         secret: configService.get('JWT_SECRET'),
-        signOptions: { expiresIn: '1d' },
+        signOptions: { expiresIn: '7d' },
       }),
     }),
   ],

src/auth/auth.swagger.ts

@@ -1,6 +1,8 @@
 import { BaseSwaggerDecorator } from 'nestjs-swagger-decorator';
 import { LoginResponse } from './dto/auth.response';
 import { BaseResponse } from 'src/common/response/dto';
+import { ErrorCodeVo } from 'src/common/exception/error';
+import { ApiInternalServerErrorResponse } from '@nestjs/swagger';
 
 // 카카오 로그인 API Swagger
 export const KakaoLoginSwagger = (text: string) => {
@@ -19,7 +21,12 @@ export const KakaoLoginSwagger = (text: string) => {
         baseResponseDto: BaseResponse,
       },
     ],
-    [],
+    [
+      ApiInternalServerErrorResponse({
+        type: ErrorCodeVo,
+        description: '서버에서 발생한 오류',
+      }),
+    ],
   );
 };
 

src/auth/strategies/kakao.strategy.ts

@@ -22,6 +22,7 @@ export class JwtKakaoStrategy extends PassportStrategy(Strategy, 'kakao') {
     done: (error: any, user?: SocialUser, info?: any) => void,
   ) {
     try {
+      console.log('profile', profile);
       const { _json } = profile;
       const kakaoUser: SocialUser = {
         kakaoId: _json.id,

src/chat-message/chat-message.module.ts

@@ -1,9 +1,13 @@
 import { Module } from '@nestjs/common';
 import { ChatMessageService } from './chat-message.service';
 import { ChatMessageController } from './chat-message.controller';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ChatMessage } from 'src/common/entities/chat-message.entity';
 
 @Module({
+  imports: [TypeOrmModule.forFeature([ChatMessage])],
   providers: [ChatMessageService],
-  controllers: [ChatMessageController]
+  controllers: [ChatMessageController],
+  exports: [ChatMessageService],
 })
 export class ChatMessageModule {}

src/chat-message/chat-message.service.ts

@@ -1,4 +1,27 @@
 import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ChatMessage } from 'src/common/entities/chat-message.entity';
+import { ChatRoom } from 'src/common/entities/chat-room.entity';
+import { CreateMatchingReqeust } from 'src/matching/dto/matching.request';
+import { QueryRunner, Repository } from 'typeorm';
 
 @Injectable()
-export class ChatMessageService {}
+export class ChatMessageService {
+  constructor(
+    @InjectRepository(ChatMessage)
+    private readonly chatMessageRepository: Repository<ChatMessage>,
+  ) {}
+
+  async createChatMessage(
+    queryRunner: QueryRunner,
+    chatRoom: ChatRoom,
+    body: CreateMatchingReqeust,
+  ): Promise<ChatMessage> {
+    return queryRunner.manager.save(ChatMessage, {
+      chatRoom: chatRoom,
+      fromUser: { id: body.requesterId },
+      toUser: { id: body.targetId },
+      content: body.message,
+    });
+  }
+}

src/chat-room/chat-room.module.ts

@@ -1,9 +1,13 @@
 import { Module } from '@nestjs/common';
 import { ChatRoomController } from './chat-room.controller';
 import { ChatRoomService } from './chat-room.service';
+import { ChatRoom } from 'src/common/entities/chat-room.entity';
+import { TypeOrmModule } from '@nestjs/typeorm';
 
 @Module({
+  imports: [TypeOrmModule.forFeature([ChatRoom])],
   controllers: [ChatRoomController],
   providers: [ChatRoomService],
+  exports: [ChatRoomService],
 })
 export class ChatRoomModule {}

src/chat-room/chat-room.service.ts

@@ -1,4 +1,28 @@
 import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { ChatRoom } from 'src/common/entities/chat-room.entity';
+import { Matching } from 'src/common/entities/matching.entity';
+import { CreateMatchingReqeust } from 'src/matching/dto/matching.request';
+import { Repository, QueryRunner } from 'typeorm';
 
 @Injectable()
-export class ChatRoomService {}
+export class ChatRoomService {
+  constructor(
+    @InjectRepository(ChatRoom)
+    private readonly chatRoomRepository: Repository<ChatRoom>,
+  ) {}
+
+  async createChatRoom(
+    queryRunner: QueryRunner,
+    matching: Matching,
+    body: CreateMatchingReqeust,
+  ): Promise<ChatRoom> {
+    // 채팅방 생성 로직
+    return await queryRunner.manager.save(ChatRoom, {
+      fromUser: { id: body.requesterId },
+      toUser: { id: body.targetId },
+      matching: matching,
+      requestStatus: 'pending',
+    });
+  }
+}

src/common/entities/chat-room.entity.ts

@@ -3,15 +3,18 @@ import { BaseEntity } from './base.entity';
 import { User } from './user.entity';
 import { ChatMessage } from './chat-message.entity';
 import { Matching } from './matching.entity';
+import { ApiProperty } from '@nestjs/swagger';
 
 @Entity('ChatRoom')
 export class ChatRoom extends BaseEntity {
   @ManyToOne(() => User, (user) => user.sentChatRooms)
   @JoinColumn({ name: 'fromUserId' })
+  @ApiProperty({ type: () => User, description: '채팅 요청자' })
   fromUser!: User;
 
   @ManyToOne(() => User, (user) => user.receivedChatRooms)
   @JoinColumn({ name: 'toUserId' })
+  @ApiProperty({ type: () => User, description: '채팅 신청 받는사람' })
   toUser!: User;
 
   @ManyToOne(() => Matching, (matching) => matching.chatRooms)

src/common/entities/matching.entity.ts

@@ -2,21 +2,33 @@ import { Entity, Column, ManyToOne, JoinColumn, OneToMany } from 'typeorm';
 import { BaseEntity } from './base.entity';
 import { User } from './user.entity';
 import { ChatRoom } from './chat-room.entity';
+import { ApiProperty } from '@nestjs/swagger';
 
 @Entity('Matching')
 export class Matching extends BaseEntity {
   @ManyToOne(() => User, (user) => user.requestedMatchings)
   @JoinColumn({ name: 'requesterId' })
+  @ApiProperty({ type: User, description: '매칭 요청자' })
   requester!: User;
 
   @ManyToOne(() => User, (user) => user.targetedMatchings)
   @JoinColumn({ name: 'targetId' })
+  @ApiProperty({ type: User, description: '매칭 받는사람' })
   target!: User;
 
   @Column({ type: 'text' })
+  @ApiProperty({
+    description: '매칭 요청 메시지',
+    example: '매칭 요청 합니다.',
+  })
   message!: string;
 
   @Column({ type: 'enum', enum: ['pending', 'accepted', 'rejected'] })
+  @ApiProperty({
+    enum: ['pending', 'accepted', 'rejected'],
+    description: '매칭 상태',
+    example: 'pending',
+  })
   requestStatus: 'pending' | 'accepted' | 'rejected' = 'pending';
 
   @Column({ type: 'datetime', nullable: true })

src/common/entities/user.entity.ts

@@ -7,33 +7,46 @@ import { Matching } from './matching.entity';
 import { PostLike } from './post-like.entity';
 import { PostReport } from './post-report.entity';
 import { ChatMessage } from './chat-message.entity';
+import { ApiProperty } from '@nestjs/swagger';
 
 @Entity('User')
 export class User extends BaseEntity {
   @Column({ type: 'varchar', length: 100, nullable: true })
+  @ApiProperty({ description: '카카오 고유 ID', example: '1234567890' })
   kakaoId!: string | null; // 카카오 고유 ID를 저장하는 필드
 
+  @ApiProperty({ description: '네이버 고유 ID', example: '1234567890' })
   @Column({ type: 'varchar', length: 100, nullable: true })
   naverId!: string | null; // 네이버 고유 ID를 저장하는 필드
 
+  @ApiProperty({ description: '이름', example: '홍길동' })
   @Column({ type: 'varchar', length: 100, nullable: true })
   name!: string | null;
 
+  @ApiProperty({ description: '이메일', example: '[email protected]' })
   @Column({ type: 'varchar', length: 100, nullable: true })
   email!: string | null;
 
+  @ApiProperty({ description: '닉네임', example: '마이콜' })
   @Column({ type: 'varchar', length: 10, nullable: true })
   nickname!: string | null;
 
+  @ApiProperty({ description: '전화번호', example: '010-1234-5678' })
   @Column({ type: 'varchar', length: 15, nullable: true })
   phoneNumber!: string | null;
 
+  @ApiProperty({
+    description: '프로필 사진 URL',
+    example: 'https://naver.com/profile.jpg',
+  })
   @Column({ type: 'text', nullable: true })
   profilePictureUrl!: string | null;
 
+  @ApiProperty({ description: '자기소개', example: '안녕하세요' })
   @Column({ type: 'varchar', length: 100, nullable: true })
   bio!: string | null;
 
+  @ApiProperty({ description: '회원가입 시각', example: '2021-08-01 00:00:00' })
   @Column('datetime')
   joinedAt!: Date; // joinedAt는 datetime 타입
 

src/common/exception/error/error.code.ts

@@ -1,6 +1,10 @@
-class ErrorCodeVo {
+import { ApiProperty } from '@nestjs/swagger';
+export class ErrorCodeVo {
+  @ApiProperty({ example: 404, description: 'HTTP 상태 코드' })
   readonly status: number;
+  @ApiProperty({ example: 'Entity Not Found', description: '오류 메시지' })
   readonly message: string;
+  @ApiProperty({ example: 'ENTITY_NOT_FOUND', description: '오류 메시지' })
   readonly code: string;
 
   constructor(status, message, code) {

src/common/exception/service.exception.ts

@@ -1,7 +1,6 @@
 import {
   NOT_FOUND_DATA,
   ErrorCode,
-  INVALID_INPUT_VALUE,
   UNAUTHORIZED,
   FORBIDDEN,
   INTERNAL_SERVER_ERROR,
@@ -12,9 +11,10 @@ export const DataNotFoundException = (message?: string): ServiceException => {
 };
 
 export const InvalidInputValueException = (
+  code: string,
   message?: string,
 ): ServiceException => {
-  return new ServiceException(INVALID_INPUT_VALUE, message);
+  return new ServiceException({ status: 400, message: message, code: code });
 };
 
 export const UnauthorizedException = (message?: string): ServiceException => {

src/common/response/base.response.ts

@@ -2,10 +2,12 @@ import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { setupSwagger } from './utils/swagger';
 import { ServiceExceptionToHttpExceptionFilter } from './common/exception-filter';
+import { ValidationPipe } from '@nestjs/common';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   app.useGlobalFilters(new ServiceExceptionToHttpExceptionFilter());
+  app.useGlobalPipes(new ValidationPipe());
   setupSwagger(app);
   await app.listen(process.env.PORT);
   console.log(`Application is running on: ${await app.getUrl()}`);

src/main.ts

@@ -0,0 +1,21 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsInt, IsString, MaxLength, MinLength } from 'class-validator';
+
+export class CreateMatchingReqeust {
+  @ApiProperty({ example: 1, description: '신청하는 유저 아이디' })
+  @IsInt()
+  requesterId: number;
+
+  @ApiProperty({ example: 2, description: '매칭 상대 유저 아이디' })
+  @IsInt()
+  targetId: number;
+
+  @ApiProperty({
+    description: '매칭 요청 메시지',
+    example: '안녕하세요! 매칭 요청합니다.',
+  })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(100)
+  message: string;
+}

src/matching/dto/matching.request.ts

@@ -0,0 +1,12 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class PostMatchingResponse {
+  @ApiProperty({ example: 1, description: '채팅방 아이디' })
+  chatRoomId: number;
+
+  @ApiProperty({ example: 1, description: '신청한 유저 아이디' })
+  fromUserId: number;
+
+  @ApiProperty({ example: 2, description: '매칭 상대 유저 아이디' })
+  toUserId: number;
+}

src/matching/dto/matching.response.ts

@@ -1,4 +1,12 @@
-import { Controller, Get, Patch, Post } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  Patch,
+  Post,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
 import { MatchingService } from './matching.service';
 import {
   CreateMatchingSwagger,
@@ -8,17 +16,45 @@ import {
   PatchMatchingRequestStatusSwagger,
 } from './matching.swagger';
 import { ApiBearerAuth, ApiTags } from '@nestjs/swagger';
+import { CreateMatchingReqeust } from './dto/matching.request';
+import { UserService } from 'src/user/user.service';
+import { Request } from 'express';
+import {
+  DataNotFoundException,
+  UnauthorizedException,
+} from 'src/common/exception/service.exception';
+import { BaseResponse } from 'src/common/response/dto';
+import { PostMatchingResponse } from './dto/matching.response';
+import { AuthGuard } from 'src/auth/guards/jwt.auth.guard';
 
 @ApiBearerAuth()
 @Controller('matching')
 @ApiTags('[서비스] 매칭')
 export class MatchingController {
-  constructor(private readonly matchingService: MatchingService) {}
+  constructor(
+    private readonly matchingService: MatchingService,
+    private readonly userService: UserService,
+  ) {}
 
   @Post()
+  @UseGuards(AuthGuard)
   @CreateMatchingSwagger('매칭 생성 API')
-  createMatching() {
-    // return this.userService.getHello();
+  async createMatching(
+    @Req() req: Request,
+    @Body() body: CreateMatchingReqeust,
+  ): Promise<BaseResponse<PostMatchingResponse>> {
+    if (req.user.id !== body.requesterId)
+      throw UnauthorizedException('권한이 없습니다.');
+
+    if (!(await this.userService.getUserById(body.targetId)))
+      throw DataNotFoundException('대상 유저가 존재하지 않습니다.');
+
+    const chatRoom = await this.matchingService.createMatching(body);
+    return new BaseResponse<PostMatchingResponse>(true, 'SUCCESS', {
+      chatRoomId: chatRoom.id,
+      toUserId: chatRoom.toUser.id,
+      fromUserId: chatRoom.fromUser.id,
+    });
   }
 
   @Patch()