Merge pull request #136 from DevKor-github/refactor/timetable

Refactor/timetable

Author: Devheun

src/app.module.ts

@@ -26,6 +26,7 @@ import { APP_FILTER } from '@nestjs/core';
 import { UnhandledExceptionFilter } from './common/filter/unhandled-exception.filter';
 import { KukeyExceptionFilter } from './common/filter/kukey-exception.filter';
 import { BannerModule } from './home/banner/banner.module';
+import { CommonCourseModule } from './common-course/common-course.module';
 
 console.log(`.env.${process.env.NODE_ENV}`);
 
@@ -77,6 +78,7 @@ console.log(`.env.${process.env.NODE_ENV}`);
     ReportModule,
     AttendanceCheckModule,
     BannerModule,
+    CommonCourseModule,
   ],
   controllers: [AppController],
   providers: [

src/common-course/common-course.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { CommonCourseService } from './common-course.service';
+
+@Module({
+  providers: [CommonCourseService],
+  exports: [CommonCourseService],
+})
+export class CommonCourseModule {}

src/common-course/common-course.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
+
+@Injectable()
+export class CommonCourseService {
+  constructor(
+    @InjectDataSource()
+    private readonly dataSource: DataSource,
+  ) {}
+
+  async getCourseReviewCount(
+    coursePairs: {
+      courseCode: string;
+      professorName: string;
+    }[],
+  ): Promise<Map<string, number>> {
+    if (coursePairs.length === 0) {
+      return new Map();
+    }
+
+    const placeholders = coursePairs.map(() => '(?, ?)').join(',');
+
+    const params = coursePairs.flatMap((pair) => [
+      pair.courseCode,
+      pair.professorName,
+    ]);
+
+    const query = `
+       SELECT courseCode as "courseCode", professorName as "professorName", COUNT(*) as reviewCount
+       FROM course_review
+       WHERE (courseCode, professorName) IN (${placeholders})
+       GROUP BY courseCode, professorName
+     `;
+
+    const reviewCounts = await this.dataSource.query(query, params);
+
+    const reviewCountMap = new Map<string, number>();
+    reviewCounts.forEach((item) => {
+      const key = `${item.courseCode}-${item.professorName}`;
+      reviewCountMap.set(key, parseInt(item.reviewCount));
+    });
+
+    return reviewCountMap;
+  }
+}

src/course-review/course-review.controller.ts

@@ -90,6 +90,7 @@ export class CourseReviewController {
     );
   }
 
+  // TODO: 강의관련이므로 강의평 모듈에서 강의모듈로 옮기기
   @Get('course')
   async getCoursesWithCourseReviews(
     @Query()

src/course-review/course-review.module.ts

@@ -9,13 +9,15 @@ import { CourseModule } from 'src/course/course.module';
 import { CourseReviewRecommendEntity } from 'src/entities/course-review-recommend.entity';
 import { RecentCourseReviewsStrategy } from './strategy/recent-course-reviews-strategy';
 import { GoodTeachingSkillReviewsStrategy } from './strategy/good-teaching-skill-reviews-strategy';
-
+import { CommonCourseModule } from 'src/common-course/common-course.module';
 @Module({
   imports: [
     TypeOrmModule.forFeature([CourseReviewEntity, CourseReviewRecommendEntity]),
     AuthModule,
     UserModule,
+    // TODO: CourseModule 의존성 없애기
     CourseModule,
+    CommonCourseModule,
   ],
   controllers: [CourseReviewController],
   providers: [

src/course/course.controller.ts

@@ -7,6 +7,8 @@ import { CourseDocs } from 'src/decorators/docs/course.decorator';
 import { SearchCourseNewDto } from './dto/search-course-new.dto';
 import { GetRecommendationCoursesRequestDto } from './dto/get-recommendation-courses-request.dto';
 import { CommonCourseResponseDto } from './dto/common-course-response.dto';
+import { SearchAllTimeCoursesRequestDto } from './dto/search-all-time-courses-request.dto';
+import { SearchAllTimeCoursesResponseDto } from './dto/search-all-time-courses-response.dto';
 
 @ApiTags('course')
 @CourseDocs
@@ -24,6 +26,15 @@ export class CourseController {
     );
   }
 
+  @Get('all-time')
+  async searchAllTimeCourses(
+    @Query() searchAllTimeCoursesRequestDto: SearchAllTimeCoursesRequestDto,
+  ): Promise<SearchAllTimeCoursesResponseDto> {
+    return await this.courseService.searchAllTimeCourses(
+      searchAllTimeCoursesRequestDto,
+    );
+  }
+
   @UseGuards(JwtAuthGuard)
   @Get()
   async searchCourses(

src/course/course.module.ts

@@ -10,9 +10,13 @@ import { AcademicFoundationSearchStrategy } from './strategy/academic-foundation
 import { GeneralSearchStrategy } from './strategy/general-search-strategy';
 import { MajorSearchStrategy } from './strategy/major-search-strategy';
 import { AllCoursesSearchStrategy } from './strategy/all-courses-search-strategy';
+import { CommonCourseModule } from 'src/common-course/common-course.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([CourseEntity, CourseDetailEntity])],
+  imports: [
+    TypeOrmModule.forFeature([CourseEntity, CourseDetailEntity]),
+    CommonCourseModule,
+  ],
   controllers: [CourseController],
   providers: [
     CourseService,

src/course/course.service.ts

@@ -11,14 +11,17 @@ import { SearchCourseNewDto } from './dto/search-course-new.dto';
 import { CourseSearchStrategy } from './strategy/course-search-strategy';
 import { SearchCourseReviewsWithKeywordRequest } from 'src/course-review/dto/search-course-reviews-with-keyword-request.dto';
 import { GetRecommendationCoursesRequestDto } from './dto/get-recommendation-courses-request.dto';
-
+import { SearchAllTimeCoursesRequestDto } from './dto/search-all-time-courses-request.dto';
+import { SearchAllTimeCoursesResponseDto } from './dto/search-all-time-courses-response.dto';
+import { CommonCourseService } from 'src/common-course/common-course.service';
 @Injectable()
 export class CourseService {
   constructor(
     private courseRepository: CourseRepository,
     private courseDetailRepository: CourseDetailRepository,
     @Inject('CourseSearchStrategy')
     private readonly strategies: CourseSearchStrategy[],
+    private readonly commonCourseService: CommonCourseService,
   ) {}
   async getCourse(courseId: number): Promise<CommonCourseResponseDto> {
     const course = await this.courseRepository.findOne({
@@ -222,6 +225,53 @@ export class CourseService {
     return courses.map((course) => new CommonCourseResponseDto(course));
   }
 
+  async searchAllTimeCourses(
+    searchAllTimeCoursesRequestDto: SearchAllTimeCoursesRequestDto,
+  ): Promise<SearchAllTimeCoursesResponseDto> {
+    const { keyword, cursorId } = searchAllTimeCoursesRequestDto;
+    let coursesQuery = this.courseRepository
+      .createQueryBuilder('course')
+      .where(
+        'course.courseName LIKE :keyword OR course.professorName LIKE :keyword OR course.courseCode LIKE :keyword',
+        {
+          keyword: `%${keyword}%`,
+        },
+      );
+
+    if (cursorId) {
+      coursesQuery = coursesQuery.andWhere('course.id > :cursorId', {
+        cursorId,
+      });
+    }
+
+    const courses = await coursesQuery
+      .orderBy('course.id', 'ASC')
+      .take(PaginatedCoursesDto.LIMIT)
+      .getMany();
+
+    const coursePairs = courses.map((course) => ({
+      courseCode: course.courseCode.split('-')[0],
+      professorName: course.professorName,
+    }));
+
+    const reviewCountMap =
+      await this.commonCourseService.getCourseReviewCount(coursePairs);
+
+    const coursesWithReviewCount = courses.map((course) => {
+      const key = `${course.courseCode.split('-')[0]}-${course.professorName}`;
+      return {
+        id: course.id,
+        professorName: course.professorName,
+        courseName: course.courseName,
+        courseCode: course.courseCode,
+        totalRate: course.totalRate,
+        reviewCount: reviewCountMap.get(key) || 0,
+      };
+    });
+
+    return new SearchAllTimeCoursesResponseDto(coursesWithReviewCount);
+  }
+
   private async findSearchStrategy(
     searchCourseNewDto: SearchCourseNewDto,
   ): Promise<CourseSearchStrategy> {