[volume-10] Collect, Stack, Zip

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingCommand.java

@@ -1,49 +1,40 @@
 package com.loopers.application.ranking;
 
+import com.loopers.domain.ranking.RankingPeriod;
+
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
-import java.time.format.DateTimeParseException;
 
 public record RankingCommand(
         LocalDate date,
+        RankingPeriod period,
         int page,
         int size
 ) {
     private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");
-    private static final int MAX_PAGE_SIZE = 100;
-    private static final int DEFAULT_PAGE_SIZE = 20;
 
-    public RankingCommand {
-        // 유효성 검증
-        if (page < 0) {
-            page = 0;
-        }
-        if (size <= 0 || size > MAX_PAGE_SIZE) {
-            size = DEFAULT_PAGE_SIZE;
-        }
-        if (date == null) {
-            date = LocalDate.now();
-        }
-    }
+    public static RankingCommand of(String date, String period, int page, int size) {
+        LocalDate parsedDate = (date == null || date.isBlank())
+                ? LocalDate.now()
+                : LocalDate.parse(date, DATE_FORMATTER);
+
+        RankingPeriod rankingPeriod = parsePeriod(period);
 
-    public static RankingCommand of(String dateString, int page, int size) {
-        LocalDate date = parseDate(dateString);
-        return new RankingCommand(date, page, size);
+        return new RankingCommand(parsedDate, rankingPeriod, page, size);
     }
 
-    public static RankingCommand today(int page, int size) {
-        return new RankingCommand(LocalDate.now(), page, size);
+    public static RankingCommand of(String date, int page, int size) {
+        return of(date, "daily", page, size);
     }
 
-    private static LocalDate parseDate(String dateString) {
-        if (dateString == null || dateString.isBlank()) {
-            return LocalDate.now();
+    private static RankingPeriod parsePeriod(String period) {
+        if (period == null || period.isBlank()) {
+            return RankingPeriod.DAILY;
         }
         try {
-            return LocalDate.parse(dateString, DATE_FORMATTER);
-        } catch (DateTimeParseException e) {
-            return LocalDate.now();
+            return RankingPeriod.valueOf(period.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            return RankingPeriod.DAILY;
         }
     }
 }
-

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingFacade.java

@@ -4,6 +4,7 @@
 import com.loopers.domain.product.ProductRepository;
 import com.loopers.domain.ranking.RankingEntry;
 import com.loopers.domain.ranking.RankingInfo;
+import com.loopers.domain.ranking.RankingPeriod;
 import com.loopers.domain.ranking.RankingService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -26,30 +27,37 @@ public class RankingFacade {
     private final ProductRepository productRepository;
     private final Clock clock;
 
-    /**
-     * 랭킹 페이지 조회
-     */
     @Transactional(readOnly = true)
     public RankingPageInfo getRankingPage(RankingCommand command) {
-        List<RankingEntry> entries = rankingService.getRankingPage(
-                command.date(),
-                command.page(),
-                command.size()
-        );
+        List<RankingEntry> entries;
+        Long totalCount;
+
+        switch (command.period()) {
+            case WEEKLY -> {
+                entries = rankingService.getWeeklyRankingPage(command.date(), command.page(), command.size());
+                totalCount = rankingService.getWeeklyRankingSize(command.date());
+            }
+            case MONTHLY -> {
+                entries = rankingService.getMonthlyRankingPage(command.date(), command.page(), command.size());
+                totalCount = rankingService.getMonthlyRankingSize(command.date());
+            }
+            default -> {
+                entries = rankingService.getRankingPage(command.date(), command.page(), command.size());
+                totalCount = rankingService.getRankingSize(command.date());
+            }
+        }
 
         if (entries.isEmpty()) {
-            return RankingPageInfo.empty(command.date(), command.page(), command.size());
+            return RankingPageInfo.empty(command.date(), command.period(), command.page(), command.size());
         }
 
-        // 상품 정보 조회
         List<Long> productIds = entries.stream()
                 .map(RankingEntry::productId)
                 .collect(Collectors.toList());
 
         Map<Long, Product> productMap = productRepository.findAllByIds(productIds).stream()
                 .collect(Collectors.toMap(Product::getId, p -> p));
 
-        // 랭킹 정보 조합
         List<RankingInfo> rankings = new ArrayList<>();
         long startRank = (long) command.page() * command.size() + 1;
 
@@ -69,23 +77,23 @@ public RankingPageInfo getRankingPage(RankingCommand command) {
             }
         }
 
-        Long totalCount = rankingService.getRankingSize(command.date());
-
         return RankingPageInfo.of(
                 rankings,
                 command.date(),
+                command.period(),
                 command.page(),
                 command.size(),
                 totalCount
         );
     }
 
-    /**
-     * Top-N 랭킹 조회
-     */
     @Transactional(readOnly = true)
-    public List<RankingInfo> getTopN(LocalDate date, int n) {
-        List<RankingEntry> entries = rankingService.getTopNWithScores(date, n);
+    public List<RankingInfo> getTopN(LocalDate date, RankingPeriod period, int n) {
+        List<RankingEntry> entries = switch (period) {
+            case WEEKLY -> rankingService.getWeeklyTopN(date, n);
+            case MONTHLY -> rankingService.getMonthlyTopN(date, n);
+            default -> rankingService.getTopNWithScores(date, n);
+        };
 
         if (entries.isEmpty()) {
             return List.of();
@@ -118,16 +126,23 @@ public List<RankingInfo> getTopN(LocalDate date, int n) {
         return rankings;
     }
 
-    /**
-     * 특정 상품의 순위 조회
-     */
+    @Transactional(readOnly = true)
+    public List<RankingInfo> getTopN(LocalDate date, int n) {
+        return getTopN(date, RankingPeriod.DAILY, n);
+    }
+
+    public Long getProductRank(Long productId, LocalDate date, RankingPeriod period) {
+        return switch (period) {
+            case WEEKLY -> rankingService.getWeeklyRank(productId, date);
+            case MONTHLY -> rankingService.getMonthlyRank(productId, date);
+            default -> rankingService.getRank(productId, date);
+        };
+    }
+
     public Long getProductRank(Long productId, LocalDate date) {
         return rankingService.getRank(productId, date);
     }
 
-    /**
-     * 특정 상품의 순위 조회 (오늘 기준)
-     */
     public Long getProductRankToday(Long productId) {
         return rankingService.getRank(productId, LocalDate.now(clock));
     }

apps/commerce-api/src/main/java/com/loopers/application/ranking/RankingPageInfo.java

@@ -1,30 +1,36 @@
 package com.loopers.application.ranking;
 
 import com.loopers.domain.ranking.RankingInfo;
+import com.loopers.domain.ranking.RankingPeriod;
 
 import java.time.LocalDate;
 import java.util.List;
 
 public record RankingPageInfo(
         List<RankingInfo> rankings,
         LocalDate date,
+        RankingPeriod period,
         int page,
         int size,
         Long totalCount,
         int totalPages
 ) {
-    public static RankingPageInfo of(
-            List<RankingInfo> rankings,
-            LocalDate date,
-            int page,
-            int size,
-            Long totalCount
-    ) {
+    public static RankingPageInfo of(List<RankingInfo> rankings, LocalDate date, RankingPeriod period,
+                                     int page, int size, Long totalCount) {
         int totalPages = (int) Math.ceil((double) totalCount / size);
-        return new RankingPageInfo(rankings, date, page, size, totalCount, totalPages);
+        return new RankingPageInfo(rankings, date, period, page, size, totalCount, totalPages);
+    }
+
+    public static RankingPageInfo empty(LocalDate date, RankingPeriod period, int page, int size) {
+        return new RankingPageInfo(List.of(), date, period, page, size, 0L, 0);
+    }
+
+    public static RankingPageInfo of(List<RankingInfo> rankings, LocalDate date,
+                                     int page, int size, Long totalCount) {
+        return of(rankings, date, RankingPeriod.DAILY, page, size, totalCount);
     }
 
     public static RankingPageInfo empty(LocalDate date, int page, int size) {
-        return new RankingPageInfo(List.of(), date, page, size, 0L, 0);
+        return empty(date, RankingPeriod.DAILY, page, size);
     }
 }

apps/commerce-api/src/main/java/com/loopers/domain/ranking/MonthlyRanking.java

@@ -0,0 +1,30 @@
+package com.loopers.domain.ranking;
+
+import com.loopers.infrastructure.converter.YearMonthAttributeConverter;
+import jakarta.persistence.*;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.YearMonth;
+
+@Entity
+@Getter
+@Table(name = "mv_product_rank_monthly")
+@NoArgsConstructor(access = lombok.AccessLevel.PROTECTED)
+public class MonthlyRanking {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "monthly_rank")
+    private int rank;
+
+    private Long productId;
+
+    private double score;
+
+    @Convert(converter = YearMonthAttributeConverter.class)
+    @Column(name = "month_period")
+    private YearMonth monthPeriod;
+}

apps/commerce-api/src/main/java/com/loopers/domain/ranking/RankingPeriod.java

@@ -0,0 +1,7 @@
+package com.loopers.domain.ranking;
+
+public enum RankingPeriod {
+    DAILY,
+    WEEKLY,
+    MONTHLY
+}

apps/commerce-api/src/main/java/com/loopers/domain/ranking/RankingRepository.java

@@ -0,0 +1,23 @@
+package com.loopers.domain.ranking;
+
+import java.time.LocalDate;
+import java.time.YearMonth;
+import java.util.List;
+import java.util.Optional;
+
+public interface RankingRepository {
+
+    // Weekly
+    List<WeeklyRanking> findWeeklyByDateOrderByRank(LocalDate weekStart, LocalDate weekEnd, int limit, int offset);
+
+    Optional<WeeklyRanking> findWeeklyByProductIdAndDate(Long productId, LocalDate weekStart, LocalDate weekEnd);
+
+    long countWeeklyByDate(LocalDate weekStart, LocalDate weekEnd);
+
+    // Monthly
+    List<MonthlyRanking> findMonthlyByPeriodOrderByRank(YearMonth period, int limit, int offset);
+
+    Optional<MonthlyRanking> findMonthlyByProductIdAndPeriod(Long productId, YearMonth period);
+
+    long countMonthlyByPeriod(YearMonth period);
+}