MOSU-121 refator: 신청 관련 기능 리팩토링 (구현 중, 닫지 말아주세요)

build.gradle

@@ -32,7 +32,7 @@ dependencies {
     testImplementation 'org.projectlombok:lombok'
     testCompileOnly 'org.projectlombok:lombok'
     testAnnotationProcessor 'org.projectlombok:lombok'
-    developmentOnly 'org.springframework.boot:spring-boot-devtools'
+//    developmentOnly 'org.springframework.boot:spring-boot-devtools'
     compileOnly 'org.projectlombok:lombok'
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'

src/main/java/life/mosu/mosuserver/MosuServerApplication.java

@@ -6,14 +6,9 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
 @SpringBootApplication
-@RequiredArgsConstructor
-public class MosuServerApplication implements CommandLineRunner {
+public class MosuServerApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(MosuServerApplication.class, args);
     }
-
-    @Override
-    public void run(String... args) throws Exception {
-    }
 }

src/main/java/life/mosu/mosuserver/application/application/ApplicationService.java

@@ -1,27 +1,35 @@
 package life.mosu.mosuserver.application.application;
 
+import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import life.mosu.mosuserver.application.examapplication.ExamApplicationService;
 import life.mosu.mosuserver.application.examapplication.dto.RegisterExamApplicationEvent;
 import life.mosu.mosuserver.domain.application.ApplicationJpaEntity;
 import life.mosu.mosuserver.domain.application.ApplicationJpaRepository;
 import life.mosu.mosuserver.domain.application.ExamTicketImageJpaEntity;
 import life.mosu.mosuserver.domain.application.ExamTicketImageJpaRepository;
+import life.mosu.mosuserver.domain.application.Subject;
 import life.mosu.mosuserver.domain.exam.ExamJpaEntity;
 import life.mosu.mosuserver.domain.exam.ExamJpaRepository;
 import life.mosu.mosuserver.domain.examapplication.ExamApplicationJpaEntity;
 import life.mosu.mosuserver.domain.examapplication.ExamApplicationJpaRepository;
 import life.mosu.mosuserver.domain.examapplication.ExamSubjectJpaEntity;
 import life.mosu.mosuserver.domain.examapplication.ExamSubjectJpaRepository;
+import life.mosu.mosuserver.domain.payment.PaymentJpaEntity;
+import life.mosu.mosuserver.domain.payment.PaymentJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.global.util.FileRequest;
+import life.mosu.mosuserver.infra.respository.ExamApplicationBulkRepository;
 import life.mosu.mosuserver.presentation.application.dto.ApplicationRequest;
 import life.mosu.mosuserver.presentation.application.dto.ApplicationResponse;
+import life.mosu.mosuserver.presentation.application.dto.CreateApplicationResponse;
 import life.mosu.mosuserver.presentation.application.dto.ExamApplicationRequest;
-import life.mosu.mosuserver.presentation.application.dto.ExamWithSubjects;
+import life.mosu.mosuserver.presentation.application.dto.ExamApplicationResponse;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -39,18 +47,34 @@ public class ApplicationService {
     private final ExamSubjectJpaRepository examSubjectJpaRepository;
     private final ExamApplicationJpaRepository examApplicationJpaRepository;
     private final ExamJpaRepository examJpaRepository;
+    private final ExamApplicationBulkRepository examApplicationBulkRepository;
+    private final PaymentJpaRepository paymentJpaRepository;
+
 
     @Transactional
-    public ApplicationResponse apply(Long userId, ApplicationRequest request) {
+    public CreateApplicationResponse apply(Long userId, ApplicationRequest request) {
 
-        // 중복 신청 검증
-        List<Long> examIds = request.examApplication().stream()
+        List<ExamApplicationRequest> examApplicationRequests = request.examApplication();
+        Set<Subject> subjects = request.validatedSubjects();
+
+        List<Long> examIds = examApplicationRequests.stream()
                 .map(ExamApplicationRequest::examId)
                 .toList();
 
-        // examId 가 동일 하냐?
-        //다른 exam 인데 시간이 같나?
-        //exam_id lunch_id 쌍으로 포함된 exam_application 이 존재하냐
+        // 중복 신청 검증
+        Set<Long> examIdSet = new HashSet<>(examIds);
+        if (examIds.size() != examIdSet.size()) {
+            throw new RuntimeException("같은 시험을 신청할 수 없습니다.");
+        }
+
+        // 신청을 1개 이상 신청했는지 검증
+        if (examIds.isEmpty()) {
+            throw new CustomRuntimeException(ErrorCode.EXAM_APPLICATION_NOT_FOUND);
+        }
+
+        //해당 시험이 진짜 있는 일정인지, lunch 가 없는 시험인데 lunch 를 신청했는지
+        validateExamIdsAndLunchSelection(examApplicationRequests);
+
         boolean isDuplicate = applicationJpaRepository.existsByUserIdAndExamIds(userId, examIds);
         if (isDuplicate) {
             throw new CustomRuntimeException(ErrorCode.APPLICATION_SCHOOL_DUPLICATED);
@@ -63,82 +87,163 @@ public ApplicationResponse apply(Long userId, ApplicationRequest request) {
         List<ExamApplicationJpaEntity> examApplicationEntities = examApplicationService.register(
                 RegisterExamApplicationEvent.of(request.examApplication(), applicationId)
         );
-        examApplicationJpaRepository.saveAll(examApplicationEntities);
 
-        List<ExamSubjectJpaEntity> allExamSubjects = examApplicationEntities.stream()
-                .flatMap(examApplication -> {
-                    Long examApplicationId = examApplication.getId();
-                    return request.validatedSubjects().stream()
-                            .map(subject -> ExamSubjectJpaEntity.create(examApplicationId,
-                                    subject));
-                })
-                .toList();
-
-        examSubjectJpaRepository.saveAll(allExamSubjects);
+        // 시험 신청 목록과 과목 multi-insert
+        examApplicationBulkRepository.saveAllExamApplicationsWithSubjects(examApplicationEntities,
+                subjects);
 
+        // 수험표 저장
         FileRequest fileReq = request.admissionTicket();
         if (fileReq.fileName() != null && fileReq.s3Key() != null) {
             ExamTicketImageJpaEntity examTicketImage = fileReq
                     .toExamTicketImageEntity(applicationId);
 
             examTicketImageJpaRepository.save(examTicketImage);
         }
-        return ApplicationResponse.of(applicationId);
+        return CreateApplicationResponse.of(applicationId);
     }
 
 
-    // 전체 신청 내역 조회
+    // TODO: 테스트 필요
     @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
     public List<ApplicationResponse> getApplications(Long userId) {
-        List<ApplicationJpaEntity> applications = applicationJpaRepository.findAllByUserId(userId);
 
+        List<ApplicationJpaEntity> applications = getUserApplications(userId);
+
+        List<ExamApplicationJpaEntity> examApplications = getExamApplications(applications);
+
+        Map<Long, ExamJpaEntity> examMap = getExamMap(examApplications);
+
+        Map<Long, List<ExamSubjectJpaEntity>> subjectMap = getSubjectMap(examApplications);
+
+        Map<Long, List<ExamApplicationResponse>> examResponsesGroupedByApplicationId =
+                groupExamResponsesByApplication(examApplications, examMap, subjectMap);
+
+        return applications.stream()
+                .map(app -> ApplicationResponse.of(
+                        app.getId(),
+                        examResponsesGroupedByApplicationId.getOrDefault(app.getId(), List.of())
+                ))
+                .toList();
+    }
+
+    private void validateExamIdsAndLunchSelection(List<ExamApplicationRequest> requests) {
+
+        List<Long> examIds = requests.stream()
+                .map(ExamApplicationRequest::examId).toList();
+
+        List<ExamJpaEntity> existingExams = examJpaRepository.findAllById(examIds);
+        if (existingExams.size() != examIds.size()) {
+            throw new CustomRuntimeException(ErrorCode.EXAM_NOT_FOUND);
+        }
+
+        Set<Long> examsWithoutLunch = existingExams.stream()
+                .filter(exam -> exam.getLunchName() == null)
+                .map(ExamJpaEntity::getId)
+                .collect(Collectors.toSet());
+
+        boolean invalidLunchSelection = requests.stream()
+                .anyMatch(req -> examsWithoutLunch.contains(req.examId()) && req.isLunchChecked());
+
+        if (invalidLunchSelection) {
+            throw new CustomRuntimeException(ErrorCode.LUNCH_SELECTION_INVALID);
+        }
+    }
+
+    private List<ApplicationJpaEntity> getUserApplications(Long userId) {
+        List<ApplicationJpaEntity> applications = applicationJpaRepository.findAllByUserId(userId);
         if (applications.isEmpty()) {
             throw new CustomRuntimeException(ErrorCode.APPLICATION_LIST_NOT_FOUND);
         }
+        return applications;
+    }
 
-        return applications.stream()
-                .map(application -> {
-                    // 해당 신청의 시험 신청들 조회
-                    List<ExamApplicationJpaEntity> examApplications =
-                            examApplicationJpaRepository.findByApplicationId(application.getId());
-
-                    if (examApplications.isEmpty()) {
-                        throw new CustomRuntimeException(ErrorCode.EXAM_APPLICATION_NOT_FOUND);
-                    }
-                    // ExamWithSubjects 리스트 생성
-                    List<ExamWithSubjects> exams = examApplications.stream()
-                            .map(examApplication -> {
-                                // 시험 정보 조회
-                                ExamJpaEntity exam = examJpaRepository.findById(
-                                                examApplication.getExamId())
-                                        .orElseThrow(() -> new CustomRuntimeException(
-                                                ErrorCode.EXAM_NOT_FOUND));
-
-                                // 과목 정보 조회
-                                List<ExamSubjectJpaEntity> examSubjects =
-                                        examSubjectJpaRepository.findByExamApplicationId(
-                                                examApplication.getId());
-                                Set<String> subjects = examSubjects.stream()
-                                        .map(examSubject -> examSubject.getSubject()
-                                                .getSubjectName())
-                                        .collect(Collectors.toSet());
-
-                                // ExamWithSubjects 생성
-                                return new ExamWithSubjects(
-                                        examApplication.getId(),
-                                        exam.getArea().getAreaName(),
-                                        exam.getExamDate(),
-                                        exam.getSchoolName(),
-                                        null,
-                                        examApplication.getExamNumber() != null
-                                                ? examApplication.getExamNumber() : "",
-                                        subjects
-                                );
-                            })
-                            .toList();
-
-                    return ApplicationResponse.of(application.getId(), exams);
-                })
+    private List<ExamApplicationJpaEntity> getExamApplications(
+            List<ApplicationJpaEntity> applications) {
+        List<Long> applicationIds = applications.stream()
+                .map(ApplicationJpaEntity::getId)
+                .toList();
+
+        List<ExamApplicationJpaEntity> examApplications =
+                examApplicationJpaRepository.findByApplicationIdIn(applicationIds);
+
+        if (examApplications.isEmpty()) {
+            throw new CustomRuntimeException(ErrorCode.EXAM_APPLICATION_NOT_FOUND);
+        }
+        return examApplications;
+    }
+
+    private Map<Long, ExamJpaEntity> getExamMap(List<ExamApplicationJpaEntity> examApplications) {
+        List<Long> examIds = examApplications.stream()
+                .map(ExamApplicationJpaEntity::getExamId)
+                .distinct()
                 .toList();
+
+        return examJpaRepository.findByIdIn(examIds).stream()
+                .collect(Collectors.toMap(ExamJpaEntity::getId, Function.identity()));
+    }
+
+    private Map<Long, PaymentJpaEntity> getPaymentMap(
+            List<ExamApplicationJpaEntity> examApplications) {
+        List<Long> examApplicationIds = examApplications.stream()
+                .map(ExamApplicationJpaEntity::getId)
+                .toList();
+
+        return paymentJpaRepository.findByExamApplicationIdIn(examApplicationIds).stream()
+                .collect(Collectors.toMap(PaymentJpaEntity::getExamApplicationId,
+                        Function.identity()));
+    }
+
+    private Map<Long, List<ExamSubjectJpaEntity>> getSubjectMap(
+            List<ExamApplicationJpaEntity> examApplications) {
+        List<Long> examApplicationIds = examApplications.stream()
+                .map(ExamApplicationJpaEntity::getId)
+                .toList();
+
+        return examSubjectJpaRepository.findByExamApplicationIdIn(examApplicationIds).stream()
+                .collect(Collectors.groupingBy(ExamSubjectJpaEntity::getExamApplicationId));
+    }
+
+    private Map<Long, List<ExamApplicationResponse>> groupExamResponsesByApplication(
+            List<ExamApplicationJpaEntity> examApplications,
+            Map<Long, ExamJpaEntity> examMap,
+            Map<Long, List<ExamSubjectJpaEntity>> subjectMap
+    ) {
+        Map<Long, PaymentJpaEntity> paymentMap = getPaymentMap(examApplications);
+
+        return examApplications.stream()
+                .map(examApplication -> {
+                    Long examApplicationId = examApplication.getId();
+                    ExamJpaEntity exam = examMap.get(examApplication.getExamId());
+
+                    Set<String> subjects = subjectMap.getOrDefault(examApplicationId, List.of())
+                            .stream()
+                            .map(es -> es.getSubject().getSubjectName())
+                            .collect(Collectors.toSet());
+
+                    PaymentJpaEntity payment = paymentMap.get(examApplicationId);
+                    String paymentStatus =
+                            (payment != null) ? payment.getPaymentStatus().name() : null;
+                    Integer totalAmount = (payment != null && payment.getPaymentAmount() != null)
+                            ? payment.getPaymentAmount().getTotalAmount()
+                            : 0;
+
+                    ExamApplicationResponse response = ExamApplicationResponse.of(
+                            examApplicationId,
+                            examApplication.getCreatedAt(),
+                            paymentStatus,
+                            totalAmount,
+                            exam.getSchoolName(),
+                            exam.getExamDate(),
+                            subjects,
+                            examApplication.getIsLunchChecked() ? exam.getLunchName() : "신청 안 함"
+                    );
+
+                    return Map.entry(examApplication.getApplicationId(), response);
+                })
+                .collect(Collectors.groupingBy(
+                        Map.Entry::getKey,
+                        Collectors.mapping(Map.Entry::getValue, Collectors.toList())
+                ));
     }
 }

src/main/java/life/mosu/mosuserver/application/exam/ExamQuotaCacheManager.java

@@ -48,8 +48,7 @@ public void addSchoolCurrentApplicationCount(String schoolName, Long currentCoun
         String key = REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS + schoolName;
         redisTemplate.opsForValue().set(key, currentCount);
     }
-
-
+
     public Long getSchoolApplicationCounts(String schoolName) {
         return redisTemplate.opsForValue()
                 .get(REDIS_KEY_SCHOOL_CURRENT_APPLICATIONS + schoolName);

src/main/java/life/mosu/mosuserver/application/exam/ExamService.java

@@ -36,7 +36,15 @@ public List<ExamResponse> getByArea(String areaName) {
         return ExamResponse.fromList(foundExams);
     }
 
-    public List<Area> getDistinctAreas() {
-        return examJpaRepository.findDistinctAreas();
+    public List<String> getDistinctAreas() {
+        return examJpaRepository.findDistinctAreas().stream()
+                .map(Area::getAreaName)
+                .toList();
     }
+
+    public List<ExamResponse> getExams() {
+        List<ExamJpaEntity> exams = examJpaRepository.findAll();
+        return ExamResponse.fromList(exams);
+    }
+
 }