Merge pull request #626 from Podo-Store/develop

[FEAT] 신청된 공연에서 환불 여부 전달

Author: pipi-shortstocking

src/main/java/PodoeMarket/podoemarket/common/repository/ApplicantRepository.java

@@ -7,5 +7,4 @@
 
 public interface ApplicantRepository extends JpaRepository<ApplicantEntity, Long> {
     ApplicantEntity findByOrderItemId(UUID orderItem);
-    Boolean existsByOrderItemId(UUID orderItem);
 }

src/main/java/PodoeMarket/podoemarket/common/repository/OrderItemRepository.java

@@ -58,16 +58,14 @@ SELECT COALESCE(SUM(oi.performanceAmount), 0)
     """)
     long sumPaidPerformanceAmountByProductId(@Param("productId") UUID productId, @Param("status") OrderStatus status);
 
-    List<OrderItemEntity> findAllByProductId(UUID productId);
-
     @Query("""
     SELECT oi FROM OrderItemEntity oi
     JOIN oi.product p
     JOIN p.user u
     WHERE p.title LIKE %:keyword%
     OR p.writer LIKE %:keyword%
     OR u.nickname LIKE %:keyword%
-""")
+    """)
     Page<OrderItemEntity> findOrderItemsByKeyword(@Param("keyword") String keyword, Pageable pageable);
 
     Boolean existsByProduct_IdAndUser_IdAndScriptTrueAndOrder_OrderStatusAndCreatedAtAfter(UUID productId, UUID userId, OrderStatus status, LocalDateTime oneYearAgo);
@@ -81,4 +79,15 @@ SELECT MAX(o.createdAt)
     AND o.order.orderStatus = :status
     """)
     LocalDateTime findLastScriptPurchaseDate(@Param("productId") UUID productId, @Param("userId") UUID userId, @Param("status") OrderStatus status);
+
+    @Query("""
+    SELECT DISTINCT o FROM OrderItemEntity o
+    JOIN FETCH o.applicant
+    JOIN FETCH o.order
+    LEFT JOIN FETCH o.performanceDate
+    WHERE o.product.id = :productId
+    AND o.performanceAmount >= 1
+    AND o.applicant IS NOT NULL
+    """)
+    List<OrderItemEntity> findOrderItemsWithApplicant(@Param("productId") UUID productId);
 }

src/main/java/PodoeMarket/podoemarket/common/repository/RefundRepository.java

@@ -43,5 +43,4 @@ SELECT r.order.id, COALESCE(SUM(r.quantity), 0)
     GROUP BY r.order.id
 """)
     List<Object[]> sumRefundQuantityByOrderIds(@Param("orderIds") List<Long> orderIds);
-
 }

src/main/java/PodoeMarket/podoemarket/common/repository/UserRepository.java

@@ -14,5 +14,4 @@ public interface UserRepository extends JpaRepository<UserEntity, Long> {
     Boolean existsByEmail(String email);
     Boolean existsByNickname(String nickname);
     UserEntity findByEmail(String email);
-    Boolean existsById(UUID id);
 }

src/main/java/PodoeMarket/podoemarket/profile/dto/response/RequestedPerformanceResponseDTO.java

@@ -61,5 +61,6 @@ public static class ApplicantInfo {
     @AllArgsConstructor
     public static class PerformanceDate {
         private LocalDateTime date;
+        private Boolean isRefunded;
     }
 }

src/main/java/PodoeMarket/podoemarket/profile/service/MypageService.java

@@ -840,52 +840,91 @@ private RequestedPerformanceResponseDTO.ProductInfo getProductInfo(final UUID pr
         }
     }
 
-    private List<RequestedPerformanceResponseDTO.DateRequestedList> getDateRequestedList (final UUID productId) {
+    private List<RequestedPerformanceResponseDTO.DateRequestedList> getDateRequestedList(final UUID productId) {
         try {
-            // 모든 주문 데이터 가져오기
-            final List<OrderItemEntity> orderItems = orderItemRepo.findAllByProductId(productId);
+            final List<OrderItemEntity> orderItems = orderItemRepo.findOrderItemsWithApplicant(productId);
 
-            List<OrderItemEntity> filteredOrderItems = orderItems.stream()
-                    .filter(orderItem -> orderItem.getPerformanceAmount() >= 1)
-                    .filter(orderItem -> orderItem.getApplicant() != null)
-                    .toList();
+            if (orderItems.isEmpty())
+                return Collections.emptyList();
+
+            final Map<Long, Integer> refundMap = getRefundQuantityMap(orderItems);
 
-            // 날짜별 그룹화
-            Map<LocalDate, List<OrderItemEntity>> groupedByOrderDate = filteredOrderItems.stream()
-                    .collect(Collectors.groupingBy(orderItem -> orderItem.getCreatedAt().toLocalDate()));
+            final Map<LocalDate, List<OrderItemEntity>> groupedByDate = orderItems.stream()
+                    .collect(Collectors.groupingBy(o -> o.getCreatedAt().toLocalDate()));
 
-            return groupedByOrderDate.entrySet().stream()
+            return groupedByDate.entrySet().stream()
                     .sorted(Map.Entry.<LocalDate, List<OrderItemEntity>>comparingByKey().reversed())
-                    .map(entry -> {
-                        LocalDate date = entry.getKey();
-                        List<OrderItemEntity> orderItemList = entry.getValue();
-
-                        // 각 주문에 대한 신청자 정보
-                        List<RequestedPerformanceResponseDTO.ApplicantInfo> applicantInfoList = orderItemList.stream()
-                                .sorted(Comparator.comparing(OrderItemEntity::getCreatedAt).reversed())
-                                .map(orderItem -> RequestedPerformanceResponseDTO.ApplicantInfo.builder()
-                                        .amount(orderItem.getPerformanceAmount())
-                                        .name(orderItem.getApplicant().getName())
-                                        .phoneNumber(orderItem.getApplicant().getPhoneNumber())
-                                        .address(orderItem.getApplicant().getAddress())
-                                        .performanceDateList(orderItem.getPerformanceDate().stream()
-                                                .map(performanceDate -> RequestedPerformanceResponseDTO.PerformanceDate.builder()
-                                                        .date(performanceDate.getDate())
-                                                        .build())
-                                                .collect(Collectors.toList()))
-                                        .build())
-                                .toList();
-
-                        return RequestedPerformanceResponseDTO.DateRequestedList.builder()
-                                .date(date)
-                                .requestedInfo(applicantInfoList)
-                                .build();
-                    }).toList();
+                    .map(entry -> buildDateRequestedList(entry, refundMap))
+                    .toList();
         } catch (Exception e) {
             throw new RuntimeException("날짜별 요청 목록 조회 실패", e);
         }
     }
 
+    private RequestedPerformanceResponseDTO.DateRequestedList buildDateRequestedList(Map.Entry<LocalDate, List<OrderItemEntity>> entry, Map<Long, Integer> refundMap) {
+        try {
+            final LocalDate date = entry.getKey();
+
+            final List<RequestedPerformanceResponseDTO.ApplicantInfo> applicants =
+                    entry.getValue().stream()
+                            .sorted(Comparator.comparing(OrderItemEntity::getCreatedAt).reversed())
+                            .map(orderItem -> buildApplicantInfo(orderItem, refundMap))
+                            .toList();
+
+            return RequestedPerformanceResponseDTO.DateRequestedList.builder()
+                    .date(date)
+                    .requestedInfo(applicants)
+                    .build();
+        } catch (Exception e) {
+            throw new RuntimeException("날짜별 DTO 생성", e);
+        }
+    }
+
+    private RequestedPerformanceResponseDTO.ApplicantInfo buildApplicantInfo(OrderItemEntity orderItem, Map<Long, Integer> refundMap) {
+        try {
+            final Long orderId = orderItem.getOrder().getId();
+
+            final int totalAmount = orderItem.getPerformanceAmount();
+            final int refundedAmount = refundMap.getOrDefault(orderId, 0);
+
+            final int validCount = Math.max(0, totalAmount - refundedAmount);
+
+            final List<RequestedPerformanceResponseDTO.PerformanceDate> performanceDates = buildPerformanceDates(orderItem.getPerformanceDate(), totalAmount, validCount);
+
+            return RequestedPerformanceResponseDTO.ApplicantInfo.builder()
+                    .amount(totalAmount)
+                    .name(orderItem.getApplicant().getName())
+                    .phoneNumber(orderItem.getApplicant().getPhoneNumber())
+                    .address(orderItem.getApplicant().getAddress())
+                    .performanceDateList(performanceDates)
+                    .build();
+        } catch (Exception e) {
+            throw new RuntimeException("신청자 dto 생성 실패", e);
+        }
+    }
+
+    private List<RequestedPerformanceResponseDTO.PerformanceDate> buildPerformanceDates(List<PerformanceDateEntity> dates, int totalAmount, int validCount) {
+        try {
+            final List<RequestedPerformanceResponseDTO.PerformanceDate> result = new ArrayList<>();
+
+            final int size = !dates.isEmpty() ? dates.size() : totalAmount;
+
+            for (int i = 0; i < size; i++) {
+                final boolean isRefunded = i >= validCount;
+
+                result.add(RequestedPerformanceResponseDTO.PerformanceDate.builder()
+                                .date(!dates.isEmpty() ? dates.get(i).getDate() : null)
+                                .isRefunded(isRefunded)
+                                .build()
+                );
+            }
+
+            return result;
+        } catch (Exception e) {
+            throw new RuntimeException("공연 신청 목록 전체 로딩 실패", e);
+        }
+    }
+
     private void deleteScripts(final ProductEntity product) {
         try {
             final String filePath = product.getFilePath().replace("script", "delete");