ApplicationService.java

package life.mosu.mosuserver.application.application;

import java.util.List;
import java.util.Set;
import life.mosu.mosuserver.application.application.dto.RegisterApplicationCommand;
import life.mosu.mosuserver.application.application.processor.GetApplicationsStepProcessor;
import life.mosu.mosuserver.application.application.processor.RegisterApplicationStepProcessor;
import life.mosu.mosuserver.application.application.processor.SaveExamTicketStepProcessor;
import life.mosu.mosuserver.application.application.validator.ApplicationValidator;
import life.mosu.mosuserver.application.exam.cache.ExamQuotaCacheManager;
import life.mosu.mosuserver.application.user.UserService;
import life.mosu.mosuserver.domain.application.entity.ApplicationJpaEntity;
import life.mosu.mosuserver.domain.application.entity.Subject;
import life.mosu.mosuserver.domain.application.repository.ApplicationJpaRepository;
import life.mosu.mosuserver.domain.exam.entity.ExamJpaEntity;
import life.mosu.mosuserver.domain.exam.entity.ExamJpaRepository;
import life.mosu.mosuserver.presentation.application.dto.ApplicationGuestRequest;
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.common.FileRequest;
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;

@Service
@RequiredArgsConstructor
@Slf4j
public class ApplicationService {

    private final UserService userService;

    private final ApplicationJpaRepository applicationJpaRepository;
    private final ExamJpaRepository examJpaRepository;
    private final ExamQuotaCacheManager cacheManager;
    private final RegisterApplicationStepProcessor registerApplicationStepProcessor;
    private final SaveExamTicketStepProcessor saveExamTicketStepProcessor;
    private final GetApplicationsStepProcessor getApplicationsStepProcessor;
    private final ApplicationValidator validator;

    @Transactional
    public CreateApplicationResponse apply(Long userId, ApplicationRequest request) {
        List<Long> examIds = request.examApplication().stream()
                .map(ExamApplicationRequest::examId)
                .toList();

        validator.agreedToTerms(request);
        validator.requestNoDuplicateExams(examIds);
        return handleApplication(
                userId,
                examIds,
                request.getSubjects(),
                request.toApplicationJpaEntity(userId),
                request.examApplication(),
                request.admissionTicket()
        );
    }

    @Transactional
    public CreateApplicationResponse applyByGuest(ApplicationGuestRequest request) {
        Long userId = userService.saveOrGetUser(request.toUserJpaEntity());
        CreateApplicationResponse response = handleApplication(
                userId,
                List.of(request.examApplication().examId()),
                request.getSubjects(),
                request.toApplicationJpaEntity(userId),
                List.of(request.examApplication()),
                request.admissionTicket());
        cacheManager.increaseCurrentApplications(request.examApplication().examId());
        return response;
    }

    private CreateApplicationResponse handleApplication(
            Long userId,
            List<Long> examIds,
            Set<Subject> subjects,
            ApplicationJpaEntity applicationEntity,
            List<ExamApplicationRequest> examApplications,
            FileRequest admissionTicket
    ) {
        List<ExamJpaEntity> exams = examJpaRepository.findAllById(examIds);
        validator.examDateNotPassed(exams);
        validator.examNotFull(exams);
        validator.examIdsAndLunchSelection(examApplications);
        validator.noDuplicateApplication(userId, examIds);

        ApplicationJpaEntity savedApplication = applicationJpaRepository.save(applicationEntity);
        Long applicationId = savedApplication.getId();

        registerApplicationStepProcessor.process(
                RegisterApplicationCommand.of(userId, applicationId, examApplications, subjects));

        saveExamTicketStepProcessor.process(
                ApplicationProcessingContext.of(applicationId, admissionTicket));

        return CreateApplicationResponse.of(applicationId);
    }

    @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
    public List<ApplicationResponse> getApplications(Long userId) {
        return getApplicationsStepProcessor.process(userId);
    }
}