지원서 지원 학기 필드 추가

src/main/java/com/example/solidconnection/application/domain/Application.java

@@ -48,6 +48,9 @@ public class Application {
     @Column(columnDefinition = "int not null default 0")
     private Integer updateCount;
 
+    @Column(length = 50, nullable = false)
+    private String term;
+
     @ManyToOne
     private UniversityInfoForApply firstChoiceUniversity;
 
@@ -63,10 +66,14 @@ public class Application {
     public Application(
             SiteUser siteUser,
             Gpa gpa,
-            LanguageTest languageTest) {
+            LanguageTest languageTest,
+            String term) {
         this.siteUser = siteUser;
         this.gpa = gpa;
         this.languageTest = languageTest;
+        this.term = term;
+        this.updateCount = 0;
+        this.verifyStatus = PENDING;
     }
 
     public void updateGpaAndLanguageTest(

src/main/java/com/example/solidconnection/application/dto/UniversityApplicantsResponse.java

@@ -25,7 +25,7 @@ public record UniversityApplicantsResponse(
 
     public static UniversityApplicantsResponse of(UniversityInfoForApply universityInfoForApply, List<ApplicantResponse> applicant) {
         return new UniversityApplicantsResponse(
-                universityInfoForApply.getUniversity().getKoreanName(),
+                universityInfoForApply.getKoreanName(),
                 universityInfoForApply.getStudentCapacity(),
                 universityInfoForApply.getUniversity().getRegion().getKoreanName(),
                 universityInfoForApply.getUniversity().getCountry().getKoreanName(),

src/main/java/com/example/solidconnection/application/repository/ApplicationRepository.java

@@ -18,18 +18,18 @@ public interface ApplicationRepository extends JpaRepository<Application, Long>
 
     boolean existsByNicknameForApply(String nicknameForApply);
 
-    Optional<Application> findBySiteUser_Email(String email);
+    Optional<Application> findTop1BySiteUser_EmailOrderByTermDesc(String email);
 
-    Optional<Application> findBySiteUser(SiteUser siteUser);
+    Optional<Application> findBySiteUserAndTerm(SiteUser siteUser, String term);
 
-    List<Application> findAllByFirstChoiceUniversityAndVerifyStatus(UniversityInfoForApply firstChoiceUniversity, VerifyStatus verifyStatus);
+    List<Application> findAllByFirstChoiceUniversityAndVerifyStatusAndTerm(UniversityInfoForApply firstChoiceUniversity, VerifyStatus verifyStatus, String term);
 
-    List<Application> findAllBySecondChoiceUniversityAndVerifyStatus(UniversityInfoForApply secondChoiceUniversity, VerifyStatus verifyStatus);
+    List<Application> findAllBySecondChoiceUniversityAndVerifyStatusAndTerm(UniversityInfoForApply secondChoiceUniversity, VerifyStatus verifyStatus, String term);
 
-    List<Application> findAllByThirdChoiceUniversityAndVerifyStatus(UniversityInfoForApply thirdChoiceUniversity, VerifyStatus verifyStatus);
+    List<Application> findAllByThirdChoiceUniversityAndVerifyStatusAndTerm(UniversityInfoForApply thirdChoiceUniversity, VerifyStatus verifyStatus, String term);
 
-    default Application getApplicationBySiteUser(SiteUser siteUser) {
-        return findBySiteUser(siteUser)
+    default Application getApplicationBySiteUserAndTerm(SiteUser siteUser, String term) {
+        return findBySiteUserAndTerm(siteUser, term)
                 .orElseThrow(() -> new CustomException(APPLICATION_NOT_FOUND));
     }
 }

src/main/java/com/example/solidconnection/application/service/ApplicationQueryService.java

@@ -52,41 +52,43 @@ public ApplicationsResponse getApplicants(String email, String regionCode, Strin
         List<University> universities
                 = universityFilterRepository.findByRegionCodeAndKeywords(regionCode, List.of(keyword));
 
-        // 1지망, 2지망 지원자들을 조회한다.
-        List<UniversityApplicantsResponse> firstChoiceApplicants = getFirstChoiceApplicants(universities, siteUser);
-        List<UniversityApplicantsResponse> secondChoiceApplicants = getSecondChoiceApplicants(universities, siteUser);
-        List <UniversityApplicantsResponse> thirdChoiceApplicants = getThirdChoiceApplicants(universities, siteUser);
+        // 1지망, 2지망, 3지망 지원자들을 조회한다.
+        List<UniversityApplicantsResponse> firstChoiceApplicants = getFirstChoiceApplicants(universities, siteUser, term);
+        List<UniversityApplicantsResponse> secondChoiceApplicants = getSecondChoiceApplicants(universities, siteUser, term);
+        List<UniversityApplicantsResponse> thirdChoiceApplicants = getThirdChoiceApplicants(universities, siteUser, term);
         return new ApplicationsResponse(firstChoiceApplicants, secondChoiceApplicants, thirdChoiceApplicants);
     }
 
+    // 학기별로 상태가 관리된다.
+    // 금학기에 지원이력이 있는 사용자만 지원정보를 확인할 수 있도록 한다.
     private void validateSiteUserCanViewApplicants(SiteUser siteUser) {
-        VerifyStatus verifyStatus = applicationRepository.getApplicationBySiteUser(siteUser).getVerifyStatus();
+        VerifyStatus verifyStatus = applicationRepository.getApplicationBySiteUserAndTerm(siteUser,term).getVerifyStatus();
         if (verifyStatus != VerifyStatus.APPROVED) {
             throw new CustomException(APPLICATION_NOT_APPROVED);
         }
     }
 
-    private List<UniversityApplicantsResponse> getFirstChoiceApplicants(List<University> universities, SiteUser siteUser) {
+    private List<UniversityApplicantsResponse> getFirstChoiceApplicants(List<University> universities, SiteUser siteUser, String term) {
         return getApplicantsByChoice(
                 universities,
                 siteUser,
-                uia -> applicationRepository.findAllByFirstChoiceUniversityAndVerifyStatus(uia, VerifyStatus.APPROVED)
+                uia -> applicationRepository.findAllByFirstChoiceUniversityAndVerifyStatusAndTerm(uia, VerifyStatus.APPROVED, term)
         );
     }
 
-    private List<UniversityApplicantsResponse> getSecondChoiceApplicants(List<University> universities, SiteUser siteUser) {
+    private List<UniversityApplicantsResponse> getSecondChoiceApplicants(List<University> universities, SiteUser siteUser, String term) {
         return getApplicantsByChoice(
                 universities,
                 siteUser,
-                uia -> applicationRepository.findAllBySecondChoiceUniversityAndVerifyStatus(uia, VerifyStatus.APPROVED)
+                uia -> applicationRepository.findAllBySecondChoiceUniversityAndVerifyStatusAndTerm(uia, VerifyStatus.APPROVED, term)
         );
     }
 
-    private List<UniversityApplicantsResponse> getThirdChoiceApplicants(List<University> universities, SiteUser siteUser) {
+    private List<UniversityApplicantsResponse> getThirdChoiceApplicants(List<University> universities, SiteUser siteUser, String term) {
         return getApplicantsByChoice(
                 universities,
                 siteUser,
-                uia -> applicationRepository.findAllByThirdChoiceUniversityAndVerifyStatus(uia, VerifyStatus.APPROVED)
+                uia -> applicationRepository.findAllByThirdChoiceUniversityAndVerifyStatusAndTerm(uia, VerifyStatus.APPROVED, term)
         );
     }
 

src/main/java/com/example/solidconnection/application/service/ApplicationSubmissionService.java

@@ -16,13 +16,9 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.HashSet;
-import java.util.Objects;
-import java.util.Set;
+import java.util.*;
 
-import static com.example.solidconnection.custom.exception.ErrorCode.APPLY_UPDATE_LIMIT_EXCEED;
-import static com.example.solidconnection.custom.exception.ErrorCode.CANT_APPLY_FOR_SAME_UNIVERSITY;
-import static com.example.solidconnection.custom.exception.ErrorCode.SCORE_SHOULD_SUBMITTED_FIRST;
+import static com.example.solidconnection.custom.exception.ErrorCode.*;
 
 @RequiredArgsConstructor
 @Service
@@ -35,11 +31,12 @@ public class ApplicationSubmissionService {
     private final SiteUserRepository siteUserRepository;
 
     @Value("${university.term}")
-    public String term;
+    private String term;
 
     /*
      * 학점과 영어 성적을 제출한다.
-     * - 기존에 제출한 적이 있다면, 수정한다.
+     * - 금학기에 제출한 적이 있다면, 수정한다.
+     * - 성적을 제출한적이 한번도 없거나 제출한적이 있지만 금학기에 제출한 적이 없다면 새로 등록한다.
      * - 수정을 하고 나면, 성적 승인 상태(verifyStatus)를 PENDING 상태로 변경한다.
      * */
     @Transactional
@@ -48,15 +45,14 @@ public boolean submitScore(String email, ScoreRequest scoreRequest) {
         Gpa gpa = scoreRequest.toGpa();
         LanguageTest languageTest = scoreRequest.toLanguageTest();
 
-        applicationRepository.findBySiteUser_Email(email)
+        applicationRepository.findBySiteUserAndTerm(siteUser, term)
                 .ifPresentOrElse(
-                        // 수정
+                        // 금학기에 성적 제출 이력이 있는 경우
                         application -> application.updateGpaAndLanguageTest(gpa, languageTest),
-
-                        // 최초 등록
-                        () -> applicationRepository.save(
-                                new Application(siteUser, gpa, languageTest)
-                        )
+                        () -> {
+                            // 성적 제출한적이 한번도 없는 경우 && 성적 제출한적이 있지만 금학기에 없는 경우
+                            applicationRepository.save(new Application(siteUser, gpa, languageTest, term));
+                        }
                 );
         return true;
     }
@@ -73,9 +69,20 @@ public boolean submitScore(String email, ScoreRequest scoreRequest) {
     @Transactional
     public boolean submitUniversityChoice(String email, UniversityChoiceRequest universityChoiceRequest) {
         validateNoDuplicateUniversityChoices(universityChoiceRequest);
-        Application application = applicationRepository.findBySiteUser_Email(email)
+
+        // 성적 제출한 적이 한번도 없는 경우
+        Application existingApplication = applicationRepository.findTop1BySiteUser_EmailOrderByTermDesc(email)
                 .orElseThrow(() -> new CustomException(SCORE_SHOULD_SUBMITTED_FIRST));
 
+        Application application = Optional.of(existingApplication)
+                .filter(app -> !app.getTerm().equals(term))
+                .map(app -> {
+                    // 성적 제출한 적이 있지만 금학기에 없는 경우, 이전 성적으로 새 Application 객체를 등록
+                    SiteUser siteUser = siteUserRepository.getByEmail(email);
+                    return applicationRepository.save(new Application(siteUser, app.getGpa(), app.getLanguageTest(), term));
+                })
+                .orElse(existingApplication); // 금학기에 이미 성적 제출한 경우 기존 객체 사용
+
         UniversityInfoForApply firstChoiceUniversity = universityInfoForApplyRepository
                 .getUniversityInfoForApplyByIdAndTerm(universityChoiceRequest.firstChoiceUniversityId(), term);
         UniversityInfoForApply secondChoiceUniversity = universityInfoForApplyRepository

src/main/java/com/example/solidconnection/application/service/VerifyStatusQueryService.java

@@ -7,6 +7,7 @@
 import com.example.solidconnection.siteuser.repository.SiteUserRepository;
 import com.example.solidconnection.type.VerifyStatus;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -25,13 +26,17 @@ public class VerifyStatusQueryService {
     private final ApplicationRepository applicationRepository;
     private final SiteUserRepository siteUserRepository;
 
+    @Value("${university.term}")
+    private String term;
+
     /*
      * 지원 상태를 조회한다.
+     * 학기별로 상태가 관리된다.
      * */
     @Transactional(readOnly = true)
     public VerifyStatusResponse getVerifyStatus(String email) {
         SiteUser siteUser = siteUserRepository.getByEmail(email);
-        Optional<Application> application = applicationRepository.findBySiteUser_Email(siteUser.getEmail());
+        Optional<Application> application = applicationRepository.findBySiteUserAndTerm(siteUser,term);
 
         // 아무것도 제출 안함
         if (application.isEmpty()) {

src/main/java/com/example/solidconnection/university/service/UniversityRecommendService.java

@@ -26,7 +26,7 @@ public class UniversityRecommendService {
     private final SiteUserRepository siteUserRepository;
 
     @Value("${university.term}")
-    public String term;
+    private String term;
 
     /*
      * 사용자 맞춤 추천 대학교를 불러온다.

src/test/java/com/example/solidconnection/e2e/ApplicantsQueryTest.java

@@ -17,6 +17,7 @@
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 
 import java.util.List;
 
@@ -42,6 +43,11 @@ class ApplicantsQueryTest extends UniversityDataSetUpEndToEndTest {
     private Application 사용자1_지원정보;
     private Application 사용자2_지원정보;
     private Application 사용자3_지원정보;
+    private Application 사용자4_이전학기_지원정보;
+
+    @Value("${university.term}")
+    private String term;
+    private String beforeTerm = "1988-1";
 
     @BeforeEach
     public void setUpUserAndToken() {
@@ -58,23 +64,27 @@ public void setUpUserAndToken() {
         SiteUser 사용자1 = siteUserRepository.save(createSiteUserByEmail("email1"));
         SiteUser 사용자2 = siteUserRepository.save(createSiteUserByEmail("email2"));
         SiteUser 사용자3 = siteUserRepository.save(createSiteUserByEmail("email3"));
+        SiteUser 사용자4_이전학기_지원자 = siteUserRepository.save(createSiteUserByEmail("email4"));
 
         // setUp - 지원 정보 저장
         Gpa gpa = createDummyGpa();
         LanguageTest languageTest = createDummyLanguageTest();
-        나의_지원정보 = new Application(siteUser, gpa, languageTest);
-        사용자1_지원정보 = new Application(사용자1, gpa, languageTest);
-        사용자2_지원정보 = new Application(사용자2, gpa, languageTest);
-        사용자3_지원정보 = new Application(사용자3, gpa, languageTest);
+        나의_지원정보 = new Application(siteUser, gpa, languageTest, term);
+        사용자1_지원정보 = new Application(사용자1, gpa, languageTest, term);
+        사용자2_지원정보 = new Application(사용자2, gpa, languageTest, term);
+        사용자3_지원정보 = new Application(사용자3, gpa, languageTest, term);
+        사용자4_이전학기_지원정보 = new Application(사용자4_이전학기_지원자, gpa, languageTest, beforeTerm);
         나의_지원정보.updateUniversityChoice(괌대학_B_지원_정보, 괌대학_A_지원_정보, 린츠_카톨릭대학_지원_정보, "0");
         사용자1_지원정보.updateUniversityChoice(괌대학_A_지원_정보, 괌대학_B_지원_정보, 그라츠공과대학_지원_정보, "1");
         사용자2_지원정보.updateUniversityChoice(메이지대학_지원_정보, 그라츠대학_지원_정보, 서던덴마크대학교_지원_정보, "2");
         사용자3_지원정보.updateUniversityChoice(네바다주립대학_라스베이거스_지원_정보, 그라츠공과대학_지원_정보, 메이지대학_지원_정보, "3");
+        사용자4_이전학기_지원정보.updateUniversityChoice(네바다주립대학_라스베이거스_지원_정보, 그라츠공과대학_지원_정보, 메이지대학_지원_정보, "4");
         나의_지원정보.setVerifyStatus(VerifyStatus.APPROVED);
         사용자1_지원정보.setVerifyStatus(VerifyStatus.APPROVED);
         사용자2_지원정보.setVerifyStatus(VerifyStatus.APPROVED);
         사용자3_지원정보.setVerifyStatus(VerifyStatus.APPROVED);
-        applicationRepository.saveAll(List.of(나의_지원정보, 사용자1_지원정보, 사용자2_지원정보, 사용자3_지원정보));
+        사용자4_이전학기_지원정보.setVerifyStatus(VerifyStatus.APPROVED);
+        applicationRepository.saveAll(List.of(나의_지원정보, 사용자1_지원정보, 사용자2_지원정보, 사용자3_지원정보, 사용자4_이전학기_지원정보));
     }
 
     @Test
@@ -195,4 +205,33 @@ public void setUpUserAndToken() {
         assertThat(secondChoiceApplicants).containsExactlyInAnyOrder(
                 UniversityApplicantsResponse.of(메이지대학_지원_정보, List.of()));
     }
+
+    @Test
+    void 지원자를_조회할_때_이전학기_지원자는_조회되지_않는다() {
+        ApplicationsResponse response = RestAssured.given().log().all()
+                .header("Authorization", "Bearer " + accessToken)
+                .when().log().all()
+                .get("/application")
+                .then().log().all()
+                .statusCode(200)
+                .extract().as(ApplicationsResponse.class);
+
+        List<UniversityApplicantsResponse> firstChoiceApplicants = response.firstChoice();
+        List<UniversityApplicantsResponse> secondChoiceApplicants = response.secondChoice();
+        List<UniversityApplicantsResponse> thirdChoiceApplicants = response.thirdChoice();
+
+
+        assertThat(firstChoiceApplicants).doesNotContainAnyElementsOf(List.of(
+                UniversityApplicantsResponse.of(네바다주립대학_라스베이거스_지원_정보,
+                        List.of(ApplicantResponse.of(사용자4_이전학기_지원정보, false)))
+        ));
+        assertThat(secondChoiceApplicants).doesNotContainAnyElementsOf(List.of(
+                UniversityApplicantsResponse.of(네바다주립대학_라스베이거스_지원_정보,
+                        List.of(ApplicantResponse.of(사용자4_이전학기_지원정보, false)))
+        ));
+        assertThat(thirdChoiceApplicants).doesNotContainAnyElementsOf(List.of(
+                UniversityApplicantsResponse.of(네바다주립대학_라스베이거스_지원_정보,
+                        List.of(ApplicantResponse.of(사용자4_이전학기_지원정보, false)))
+        ));
+    }
 }