Issue/168/update best review

package.json

@@ -50,6 +50,7 @@
     "@nestjs/jwt": "^10.2.0",
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.4.15",
+    "@nestjs/schedule": "^4.1.2",
     "@nestjs/swagger": "^8.1.0",
     "@prisma/client": "^6.1.0",
     "@slack/web-api": "^7.8.0",
@@ -142,5 +143,6 @@
   },
   "overrides": {
     "glob": "^9"
-  }
+  },
+  "packageManager": "[email protected]+sha512.1acb565e6193efbebda772702950469150cf12bcc764262e7587e71d19dc98a423dff9536e57ea44c49bdf790ff694e83c27be5faa23d67e0c033b583be4bfcf"
 }

src/common/entities/EReview.ts

@@ -15,6 +15,17 @@ export namespace EReview {
   });
   export type Details = Prisma.review_reviewGetPayload<typeof Details>;
 
+  export const WithLectures =
+    Prisma.validator<Prisma.review_reviewDefaultArgs>()({
+      include: {
+        lecture: ELecture.Basic,
+      },
+    });
+
+  export type WithLectures = Prisma.review_reviewGetPayload<
+    typeof WithLectures
+  >;
+
   export namespace EReviewVote {
     export const Basic =
       Prisma.validator<Prisma.review_reviewvoteDefaultArgs>()({});

src/modules/reviews/reviews.controller.ts

@@ -10,13 +10,13 @@ import {
   Query,
 } from '@nestjs/common';
 import { session_userprofile } from '@prisma/client';
+import { ReviewProhibited } from '@src/common/decorators/prohibit-review.decorator';
 import { GetUser } from 'src/common/decorators/get-user.decorator';
 import { Public } from 'src/common/decorators/skip-auth.decorator';
 import { IReview } from 'src/common/interfaces/IReview';
-import { ReviewsService } from './reviews.service';
 import { EReview } from '../../common/entities/EReview';
+import { ReviewsService } from './reviews.service';
 import EReviewVote = EReview.EReviewVote;
-import { ReviewProhibited } from '@src/common/decorators/prohibit-review.decorator';
 
 @Controller('api/reviews')
 export class ReviewsController {
@@ -52,6 +52,13 @@ export class ReviewsController {
     }
   }
 
+  @Get('update-best-reviews')
+  async triggerUpdateBestReviews() {
+    console.log('Triggered manual update for Best Reviews');
+    await this.reviewsService.updateBestReviewsCron();
+    return { message: 'BestReviews update triggered successfully' };
+  }
+
   @Public()
   @Get(':reviewId')
   async getReviewInstance(

src/modules/reviews/reviews.service.ts

@@ -1,10 +1,11 @@
+import { Transactional } from '@nestjs-cls/transactional';
 import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
-import { session_userprofile } from '@prisma/client';
+import { Cron } from '@nestjs/schedule';
+import { review_review, session_userprofile } from '@prisma/client';
 import { IReview } from 'src/common/interfaces/IReview';
 import { toJsonReview } from 'src/common/interfaces/serializer/review.serializer';
 import { LectureRepository } from 'src/prisma/repositories/lecture.repository';
 import { ReviewsRepository } from 'src/prisma/repositories/review.repository';
-import { Transactional } from '@nestjs-cls/transactional';
 import { EReview } from '../../common/entities/EReview';
 import EReviewVote = EReview.EReviewVote;
 
@@ -174,4 +175,68 @@ export class ReviewsService {
   ): Promise<EReviewVote.Basic> {
     return await this.reviewsRepository.upsertReviewVote(reviewId, user.id);
   }
+
+  @Cron('0 0 * * *') // 매일 자정에 실행하는 Cron 작업 설정: 과거 update-best-reviews.py를 계승
+  async updateBestReviewsCron() {
+    function calculateKey(review: EReview.WithLectures): number {
+      const baseYear = new Date().getFullYear();
+      const lectureYear = review.lecture.year;
+      const yearDiff = baseYear - lectureYear > 0 ? baseYear - lectureYear : 0;
+      return Math.floor(
+        (review.like / (review.lecture.audience + 1)) *
+          Math.pow(0.85, yearDiff),
+      );
+    }
+
+    function getBestReviews(
+      reviews: EReview.WithLectures[],
+      minLikedCount: number,
+      maxResultCount: number,
+    ): review_review[] {
+      const likedCount = Math.max(
+        minLikedCount,
+        Math.floor(reviews.length / 10),
+      );
+
+      const mostLikedReviews = reviews
+        .sort((a, b) => calculateKey(b) - calculateKey(a))
+        .slice(0, likedCount);
+
+      const latestDateStart = new Date();
+      latestDateStart.setDate(latestDateStart.getDate() - 7);
+
+      const latestReviews = reviews.filter(
+        (review) =>
+          review.written_datetime &&
+          new Date(review.written_datetime) >= latestDateStart,
+      );
+
+      const bestCandidateReviews = [...mostLikedReviews, ...latestReviews];
+      return bestCandidateReviews.length > maxResultCount
+        ? bestCandidateReviews.slice(0, maxResultCount)
+        : bestCandidateReviews;
+    }
+
+    console.log('Running scheduled job: Update Best Reviews');
+
+    // Process humanity reviews
+    const humanityReviews = await this.reviewsRepository.getHumanityReviews();
+    const humanityBestReviews = getBestReviews(humanityReviews, 50, 20);
+
+    await this.reviewsRepository.clearHumanityBestReviews();
+    await this.reviewsRepository.addHumanityBestReviews(
+      humanityBestReviews.map((r) => ({ reviewId: r.id })),
+    );
+
+    // Process major reviews
+    const majorReviews = await this.reviewsRepository.getMajorReviews();
+    const majorBestReviews = getBestReviews(majorReviews, 2000, 1000);
+
+    await this.reviewsRepository.clearMajorBestReviews();
+    await this.reviewsRepository.addMajorBestReviews(
+      majorBestReviews.map((r) => ({ reviewId: r.id })),
+    );
+
+    console.log('BestReview updated by scheduled job');
+  }
 }

src/prisma/migrations/20250114231339_add_major_best_review_relation/migration.sql

@@ -0,0 +1,11 @@
+-- CreateIndex
+CREATE INDEX `review_humanitybestreview_review_id_idx` ON `review_humanitybestreview`(`review_id`);
+
+-- CreateIndex
+CREATE INDEX `review_majorbestreview_review_id_idx` ON `review_majorbestreview`(`review_id`);
+
+-- AddForeignKey
+ALTER TABLE `review_humanitybestreview` ADD CONSTRAINT `review_humanitybestreview_review_id_fkey` FOREIGN KEY (`review_id`) REFERENCES `review_review`(`id`) ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE `review_majorbestreview` ADD CONSTRAINT `review_majorbestreview_review_id_fkey` FOREIGN KEY (`review_id`) REFERENCES `review_review`(`id`) ON DELETE CASCADE ON UPDATE CASCADE;

src/prisma/repositories/review.repository.ts

@@ -401,4 +401,62 @@ export class ReviewsRepository {
       },
     });
   }
+
+  // Fetch humanity reviews (HSS department)
+  async getHumanityReviews(): Promise<EReview.WithLectures[]> {
+    return this.prisma.review_review.findMany({
+      where: {
+        course: {
+          subject_department: {
+            code: 'HSS',
+          },
+        },
+      },
+      include: {
+        lecture: true,
+      },
+    });
+  }
+
+  // Fetch major reviews (Non-HSS department)
+  async getMajorReviews(): Promise<EReview.WithLectures[]> {
+    return this.prisma.review_review.findMany({
+      where: {
+        NOT: {
+          course: {
+            subject_department: {
+              code: 'HSS',
+            },
+          },
+        },
+      },
+      include: {
+        lecture: true,
+      },
+    });
+  }
+
+  // Clear all humanity best reviews
+  async clearHumanityBestReviews() {
+    return this.prisma.review_humanitybestreview.deleteMany();
+  }
+
+  // Clear all major best reviews
+  async clearMajorBestReviews() {
+    return this.prisma.review_majorbestreview.deleteMany();
+  }
+
+  // Add new humanity best reviews
+  async addHumanityBestReviews(reviews: { reviewId: number }[]) {
+    return this.prisma.review_humanitybestreview.createMany({
+      data: reviews.map((review) => ({ review_id: review.reviewId })),
+    });
+  }
+
+  // Add new major best reviews
+  async addMajorBestReviews(reviews: { reviewId: number }[]) {
+    return this.prisma.review_majorbestreview.createMany({
+      data: reviews.map((review) => ({ review_id: review.reviewId })),
+    });
+  }
 }

src/prisma/schema.prisma

@@ -216,10 +216,16 @@ model main_reviewwritedailyuserfeed {
 
 model review_humanitybestreview {
   review_id Int @id
+  review    review_review @relation(fields: [review_id], references: [id], onDelete: Cascade)
+
+  @@index([review_id])
 }
 
 model review_majorbestreview {
-  review_id Int @id
+  review_id Int          @id
+  review    review_review @relation(fields: [review_id], references: [id], onDelete: Cascade)
+
+  @@index([review_id])
 }
 
 model review_review {
@@ -242,6 +248,9 @@ model review_review {
   lecture                                    subject_lecture                              @relation(fields: [lecture_id], references: [id])
   writer                                     session_userprofile?                         @relation(fields: [writer_id], references: [id])
   review_reviewvote                          review_reviewvote[]
+  review_majorbestreview                     review_majorbestreview?                      @relation
+  review_humanitybestreview                  review_humanitybestreview?                   @relation
+
 
   @@unique([writer_id, lecture_id], map: "review_comment_writer_id_af700a5d_uniq")
   @@index([written_datetime], map: "review_comment_e5e30a4a")