ExamApplicationService.java

package life.mosu.mosuserver.application.examapplication;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import life.mosu.mosuserver.application.examapplication.dto.RegisterExamApplicationEvent;
import life.mosu.mosuserver.domain.application.entity.Subject;
import life.mosu.mosuserver.domain.application.repository.ApplicationJpaRepository;
import life.mosu.mosuserver.domain.discount.service.FixedQuantityDiscountCalculator;
import life.mosu.mosuserver.domain.examapplication.entity.ExamApplicationJpaEntity;
import life.mosu.mosuserver.domain.examapplication.entity.ExamSubjectJpaEntity;
import life.mosu.mosuserver.domain.examapplication.projection.ExamApplicationInfoProjection;
import life.mosu.mosuserver.domain.examapplication.projection.ExamTicketInfoProjection;
import life.mosu.mosuserver.domain.examapplication.repository.ExamApplicationJpaRepository;
import life.mosu.mosuserver.domain.examapplication.repository.ExamSubjectJpaRepository;
import life.mosu.mosuserver.domain.examapplication.service.ExamNumberGenerationService;
import life.mosu.mosuserver.global.exception.CustomRuntimeException;
import life.mosu.mosuserver.global.exception.ErrorCode;
import life.mosu.mosuserver.infra.persistence.s3.S3Service;
import life.mosu.mosuserver.presentation.admin.dto.ExamTicketResponse;
import life.mosu.mosuserver.presentation.common.AddressResponse;
import life.mosu.mosuserver.presentation.examapplication.dto.ExamApplicationInfoResponse;
import life.mosu.mosuserver.presentation.examapplication.dto.UpdateSubjectRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Slf4j
@Service
@RequiredArgsConstructor
public class ExamApplicationService {

    private final ExamApplicationJpaRepository examApplicationJpaRepository;
    private final ApplicationJpaRepository applicationJpaRepository;
    private final ExamSubjectJpaRepository examSubjectJpaRepository;
    private final ExamNumberGenerationService examNumberGenerationService;
    private final S3Service s3Service;
    private final FixedQuantityDiscountCalculator calculator;


    @Transactional
    public List<ExamApplicationJpaEntity> register(RegisterExamApplicationEvent event) {
        List<ExamApplicationJpaEntity> examApplicationEntities = event.toEntity();
        examNumberGenerationService.grantTo(examApplicationEntities);
        return examApplicationEntities;
    }

    @Transactional
    public void updateSubjects(Long userId, Long examApplicationId,
            UpdateSubjectRequest request) {

        validateUser(userId, examApplicationId);
        examSubjectJpaRepository.deleteExamSubjectsWithDonePayment(examApplicationId);
        List<ExamSubjectJpaEntity> examSubjects = request.toEntityList(examApplicationId);
        examSubjectJpaRepository.saveAll(examSubjects);

    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deleteExamApplication(Long userId, Long examApplicationId) {
        validateUser(userId, examApplicationId);

        ExamApplicationJpaEntity examApplication = examApplicationJpaRepository.findById(
                        examApplicationId)
                .orElseThrow(
                        () -> new CustomRuntimeException(ErrorCode.EXAM_APPLICATION_NOT_FOUND));
        Long applicationId = examApplication.getApplicationId();

        examApplicationJpaRepository.updateDeleteById(examApplicationId);

        if (!examApplicationJpaRepository.existsByApplicationId(applicationId)) {
            applicationJpaRepository.deleteWithExamTicketById(applicationId);
        }

        examSubjectJpaRepository.deleteByExamApplicationId(examApplicationId);
    }


    @Transactional
    public ExamTicketResponse getExamTicket(Long userId, Long examApplicationId) {
        ExamTicketInfoProjection examTicketInfo = examApplicationJpaRepository.findExamTicketInfoProjectionById(
                        userId, examApplicationId)
                .orElseThrow(
                        () -> new CustomRuntimeException(ErrorCode.EXAM_RESOURCE_ACCESS_DENIED));

        validateExamTicketOpenDate(examTicketInfo.examDate(), examTicketInfo.examNumber());

        List<ExamSubjectJpaEntity> examSubjects = examSubjectJpaRepository.findByExamApplicationId(
                examApplicationId);

        List<String> subjects = examSubjects.stream()
                .map(ExamSubjectJpaEntity::getSubject)
                .map(Subject::getSubjectName)
                .toList();

        String s3Key = examTicketInfo.s3Key();
        String examTicketImgUrl = null;

        if (s3Key != null) {
            examTicketImgUrl = s3Service.getPreSignedUrl(s3Key);
        }

        return ExamTicketResponse.of(examTicketImgUrl, examTicketInfo.userName(),
                examTicketInfo.birth(),
                examTicketInfo.examNumber(), subjects, examTicketInfo.schoolName());

    }


    public ExamApplicationInfoResponse getApplication(Long userId, Long examApplicationId,
            Long applicationId) {
        validateUser(userId, examApplicationId);

        //상세 조회는 done 만 가능
//        Integer examApplicationCount = paymentJpaRepository.countByExamApplicationId(
//                examApplicationId);
        List<ExamApplicationJpaEntity> examApplicationEntities = examApplicationJpaRepository.findByApplicationId(
                applicationId);
        int lunchCount = (int) examApplicationEntities.stream()
                .filter(ExamApplicationJpaEntity::getIsLunchChecked)
                .count();

        ExamApplicationInfoProjection examApplicationInfo = examApplicationJpaRepository
                .findExamApplicationInfoById(userId, examApplicationId)
                .orElseThrow(
                        () -> new CustomRuntimeException(ErrorCode.EXAM_APPLICATION_NOT_FOUND));

        List<ExamSubjectJpaEntity> examSubjects =
                examSubjectJpaRepository.findByExamApplicationId(examApplicationId);

        Set<String> subjects = examSubjects.stream()
                .map(ExamSubjectJpaEntity::getSubjectName)
                .collect(Collectors.toSet());
        //totalAmount 는 Lunch 가격이 포함되었을 수도 있음
        //totalAmount - Lunch 가격으로 getAppliedDiscountAmount() 메소드에 넣어야함.

        Integer totalAmount = examApplicationInfo.paymentAmount().getTotalAmount();
        Integer discountAmount = getAppliedDiscountAmount(
                lunchCount > 0 ? totalAmount - (9000 * lunchCount)
                        : totalAmount);

        Integer paymentAmount =
                examApplicationInfo.paymentAmount().getTotalAmount() + discountAmount;

        return ExamApplicationInfoResponse.of(
                examApplicationInfo.examApplicationId(),
                examApplicationInfo.paymentKey(),
                examApplicationInfo.examDate(),
                examApplicationInfo.schoolName(),
                AddressResponse.from(examApplicationInfo.address()),
                subjects,
                examApplicationInfo.isLunchChecked() ? examApplicationInfo.lunchName() : "도시락 X",
                paymentAmount,
                discountAmount,
                examApplicationInfo.paymentMethod().getName()
        );
    }

    private void validateUser(Long userId, Long examApplicationId) {
        boolean check = examApplicationJpaRepository.existByUserIdAndExamApplicationId(
                userId,
                examApplicationId);

        if (!check) {
            throw new CustomRuntimeException(ErrorCode.USER_NOT_ACCESS_FORBIDDEN);
        }
    }

    private int getAppliedDiscountAmount(Integer totalAmount) {
        try {
            return calculator.getAppliedDiscountAmount(totalAmount);
        } catch (Exception ex) {
            throw new CustomRuntimeException(ErrorCode.PRICE_LOAD_FAILURE);
        }
    }

    private void validateExamTicketOpenDate(LocalDate examDate, String examNumber) {

        LocalDateTime openDateTime = examDate.minusDays(3).atTime(8, 0);
        LocalDateTime now = LocalDateTime.now();

        if (examNumber == null || now.isBefore(openDateTime)) {
            throw new CustomRuntimeException(ErrorCode.EXAM_TICKET_NOT_OPEN);
        }
    }
}