Merge pull request #75 from se-gam/feat/admin-studyroom

feat: 스터디룸 정보 업데이트 api

src/notice/notice.controller.ts

@@ -16,11 +16,11 @@ import {
   ApiOperation,
   ApiTags,
 } from '@nestjs/swagger';
+import { AdminApiGuard } from 'src/auth/guard/admin.guard';
+import { NoticePreviewDto } from './dto/notice-preview.dto';
 import { NoticeDto } from './dto/notice.dto';
 import { NoticeService } from './notice.service';
 import { CreateUpdateNoticePayload } from './payload/create-update-notice.payload';
-import { NoticePreviewDto } from './dto/notice-preview.dto';
-import { AdminApiGuard } from 'src/auth/guard/admin.guard';
 
 @ApiTags('공지사항 API')
 @Controller('notice')
@@ -39,7 +39,7 @@ export class NoticeController {
 
   @Version('1')
   @ApiOperation({
-    summary: '팝업 공지사항 등록 API',
+    summary: '[어드민] 팝업 공지사항 등록 API',
     description: '팝업 공지사항을 등록합니다.',
   })
   @UseGuards(AdminApiGuard)
@@ -55,7 +55,7 @@ export class NoticeController {
 
   @Version('1')
   @ApiOperation({
-    summary: '공지사항 생성 API',
+    summary: '[어드민] 공지사항 생성 API',
     description: '공지사항을 생성합니다.',
   })
   @UseGuards(AdminApiGuard)
@@ -73,7 +73,7 @@ export class NoticeController {
 
   @Version('1')
   @ApiOperation({
-    summary: '공지사항 수정 API',
+    summary: '[어드민] 공지사항 수정 API',
     description: '공지사항을 수정합니다.',
   })
   @UseGuards(AdminApiGuard)
@@ -92,7 +92,7 @@ export class NoticeController {
 
   @Version('1')
   @ApiOperation({
-    summary: '공지사항 삭제 API',
+    summary: '[어드민] 공지사항 삭제 API',
     description: '공지사항을 삭제합니다.',
   })
   @UseGuards(AdminApiGuard)

src/studyroom/dto/studyroom-infp.dto.ts

@@ -0,0 +1,94 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { StudyroomInfo } from '../types/studyroomInfo.type';
+
+export class StudyroomInfoDto {
+  @ApiProperty({
+    description: '스터디룸 id',
+    type: Number,
+  })
+  id!: number;
+
+  @ApiProperty({
+    description: '스터디룸 이름',
+    type: String,
+  })
+  name!: string;
+
+  @ApiProperty({
+    description: '위치',
+    type: String,
+  })
+  location!: string;
+  @ApiProperty({
+    description: '최소 인원',
+    type: Number,
+  })
+  minUsers!: number;
+
+  @ApiProperty({
+    description: '최대 인원',
+    type: Number,
+  })
+  maxUsers!: number;
+
+  @ApiProperty({
+    description: '스터디룸 유형',
+    type: Boolean,
+  })
+  isCinema!: boolean;
+
+  @ApiProperty({
+    description: '운영 시간',
+    type: String,
+  })
+  operatingHours!: string;
+
+  @ApiProperty({
+    description: '스터디룸 태그',
+    type: [String],
+  })
+  tags!: string[];
+
+  @ApiProperty({
+    description: '스터디룸 활성화 여부',
+    type: Boolean,
+  })
+  isActive!: boolean;
+
+  @ApiProperty({
+    description: '스터디룸 마지막 업데이트 시간',
+    type: Date,
+  })
+  lastUpdatedAt!: Date;
+
+  static from(studyroom: StudyroomInfo): StudyroomInfoDto {
+    return {
+      id: studyroom.id,
+      name: studyroom.name,
+      location: studyroom.location,
+      minUsers: studyroom.minUsers,
+      maxUsers: studyroom.maxUsers,
+      isCinema: studyroom.isCinema,
+      operatingHours: studyroom.operatingHours,
+      tags: studyroom.tags,
+      isActive: studyroom.isActive,
+      lastUpdatedAt: studyroom.lastUpdatedAt,
+    };
+  }
+}
+
+export class StudyroomInfoListDto {
+  @ApiProperty({
+    description: '스터디룸 목록',
+    type: [StudyroomInfoDto],
+  })
+  studyrooms: StudyroomInfoDto[];
+
+  static from(studyrooms: StudyroomInfo[]): StudyroomInfoListDto {
+    return {
+      studyrooms: studyrooms.map((studyroom) => {
+        return StudyroomInfoDto.from(studyroom);
+      }),
+    };
+  }
+}

src/studyroom/payload/studyroomUpdate.payload.ts

@@ -0,0 +1,11 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsBoolean } from 'class-validator';
+
+export class StudyroomUpdatePayload {
+  @ApiProperty({
+    description: '활성화 여부',
+    example: 'true',
+  })
+  @IsBoolean()
+  isActive!: boolean;
+}

src/studyroom/studyroom.controller.ts

@@ -3,6 +3,8 @@ import {
   Controller,
   Get,
   Param,
+  ParseIntPipe,
+  Patch,
   Post,
   Query,
   UseGuards,
@@ -12,22 +14,26 @@ import {
   ApiBadRequestResponse,
   ApiBearerAuth,
   ApiCreatedResponse,
+  ApiHeader,
   ApiNotFoundResponse,
   ApiOkResponse,
   ApiOperation,
   ApiTags,
   ApiUnauthorizedResponse,
 } from '@nestjs/swagger';
 import { CurrentUser } from 'src/auth/decorator/user.decorator';
+import { AdminApiGuard } from 'src/auth/guard/admin.guard';
 import { JwtAuthGuard } from 'src/auth/guard/jwt-auth.guard';
 import { PasswordPayload } from 'src/auth/payload/password.payload';
 import { PasswordValidationPipe } from 'src/auth/pipes/signup-validation.pipe';
 import { UserInfo } from 'src/auth/types/user-info.type';
+import { StudyroomInfoListDto } from './dto/studyroom-infp.dto';
 import { StudyroomReservationListDto } from './dto/studyroom-reservation.dto';
 import { StudyroomDto, StudyroomListDto } from './dto/studyroom.dto';
 import { UserPidDto } from './dto/userPid.dto';
 import { StudyroomCancelPayload } from './payload/studyroomCancel.payload';
 import { StudyroomReservePayload } from './payload/studyroomReserve.payload';
+import { StudyroomUpdatePayload } from './payload/studyroomUpdate.payload';
 import { StudyroomUserPayload } from './payload/studyroomUserPayload.payload';
 import { StudyroomQuery } from './query/studyroom.query';
 import { StudyroomDateQuery } from './query/studyroomDateQuery.query';
@@ -170,4 +176,48 @@ export class StudyroomController {
   ): Promise<UserPidDto> {
     return this.studyroomService.checkUserAvailablity(user.studentId, payload);
   }
+
+  @Version('1')
+  @ApiOperation({
+    summary: '[어드민] 스터디룸 정보 업데이트 API',
+    description: '스터디룸 정보를 업데이트 합니다.',
+  })
+  @ApiOkResponse({
+    description: '스터디룸 정보 업데이트 성공',
+  })
+  @ApiNotFoundResponse({
+    description: '해당 id의 스터디룸을 찾을 수 없습니다.',
+  })
+  @UseGuards(AdminApiGuard)
+  @ApiHeader({
+    name: 'admin-api-key',
+    description: 'API key for admin access',
+    required: true,
+  })
+  @Patch('info/:id')
+  async updateStudyroom(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() payload: StudyroomUpdatePayload,
+  ): Promise<void> {
+    return this.studyroomService.updateStudyroom(id, payload);
+  }
+
+  @Version('1')
+  @ApiOperation({
+    summary: '[어드민] 스터디룸 정보 목록 조회 API',
+    description: '스터디룸 정보 목록을 조회합니다.',
+  })
+  @ApiOkResponse({
+    description: '스터디룸 정보 목록 조회 성공',
+  })
+  @UseGuards(AdminApiGuard)
+  @ApiHeader({
+    name: 'admin-api-key',
+    description: 'API key for admin access',
+    required: true,
+  })
+  @Get('info/all')
+  async getAllStudyroomInfo(): Promise<StudyroomInfoListDto> {
+    return this.studyroomService.getAllStudyroomInfo();
+  }
 }

src/studyroom/studyroom.module.ts

@@ -6,9 +6,10 @@ import { StudyroomController } from './studyroom.controller';
 import { StudyroomRepository } from './studyroom.repository';
 import { StudyroomService } from './studyroom.service';
 import { UserService } from 'src/user/user.service';
+import { AuthModule } from 'src/auth/auth.module';
 
 @Module({
-  imports: [ScheduleModule.forRoot()],
+  imports: [ScheduleModule.forRoot(), AuthModule],
   controllers: [StudyroomController],
   providers: [
     StudyroomService,

src/studyroom/studyroom.repository.ts

@@ -1,11 +1,13 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, NotFoundException } from '@nestjs/common';
 import { StudyroomReservation as PrismaStudyroomReservation } from '@prisma/client';
 import * as _ from 'lodash';
 import { PrismaService } from 'src/common/services/prisma.service';
+import { StudyroomUpdatePayload } from './payload/studyroomUpdate.payload';
 import { StudyroomQuery } from './query/studyroom.query';
 import { StudyroomDateQuery } from './query/studyroomDateQuery.query';
 import { ReservationResponse } from './types/reservationResponse.type';
 import { Studyroom } from './types/studyroom.type';
+import { StudyroomInfo } from './types/studyroomInfo.type';
 import { StudyroomReservationInfo } from './types/studyroomReservationInfo.type';
 
 @Injectable()
@@ -17,6 +19,87 @@ export class StudyroomRepository {
     return hour + ':00';
   }
 
+  async getAllStudyroomInfo(): Promise<StudyroomInfo[]> {
+    const studyrooms = await this.prismaService.studyroom.findMany({
+      where: {
+        deletedAt: null,
+      },
+      select: {
+        id: true,
+        name: true,
+        location: true,
+        minUsers: true,
+        maxUsers: true,
+        isCinema: true,
+        operatingHours: true,
+        tags: true,
+        isActive: true,
+      },
+    });
+
+    const lastUpdatedSlots = await this.prismaService.studyroomSlot.groupBy({
+      by: ['studyroomId'],
+      _max: {
+        updatedAt: true,
+      },
+      where: {
+        studyroomId: {
+          in: studyrooms.map((studyroom) => studyroom.id),
+        },
+      },
+    });
+
+    return studyrooms.map((studyroom) => {
+      return {
+        ...studyroom,
+        lastUpdatedAt: lastUpdatedSlots.find(
+          (slot) => slot.studyroomId === studyroom.id,
+        )?._max.updatedAt,
+      };
+    });
+  }
+
+  async getStudyroomInfoById(id: number): Promise<StudyroomInfo> {
+    const studyroomInfo = await this.prismaService.studyroom.findUnique({
+      where: {
+        id: id,
+        deletedAt: null,
+      },
+      select: {
+        id: true,
+        name: true,
+        location: true,
+        minUsers: true,
+        maxUsers: true,
+        isCinema: true,
+        operatingHours: true,
+        tags: true,
+        isActive: true,
+      },
+    });
+
+    if (!studyroomInfo) {
+      throw new NotFoundException('스터디룸이 존재하지 않습니다.');
+    }
+
+    const lastUpdatedSlot = await this.prismaService.studyroomSlot.findFirst({
+      where: {
+        studyroomId: id,
+      },
+      orderBy: {
+        updatedAt: 'desc',
+      },
+      select: {
+        updatedAt: true,
+      },
+    });
+
+    return {
+      ...studyroomInfo,
+      lastUpdatedAt: lastUpdatedSlot.updatedAt,
+    };
+  }
+
   async getAllStudyroomIds(): Promise<number[]> {
     const studyrooms = await this.prismaService.studyroom.findMany({
       where: {
@@ -377,4 +460,18 @@ export class StudyroomRepository {
       }
     }
   }
+
+  async updateStudyroom(
+    id: number,
+    payload: StudyroomUpdatePayload,
+  ): Promise<void> {
+    await this.prismaService.studyroom.update({
+      where: {
+        id,
+      },
+      data: {
+        isActive: payload.isActive,
+      },
+    });
+  }
 }