[TSK-71] 기존 기필 카테고리 대체과목 보정 로직 수정하여 동일과목 학점 미인정 이슈 해결

src/main/java/kr/allcll/backend/admin/graduation/AdminGraduationSyncService.java

@@ -23,6 +23,8 @@
 import kr.allcll.backend.domain.graduation.certification.GraduationCertRuleRepository;
 import kr.allcll.backend.domain.graduation.certification.GraduationCertRuleType;
 import kr.allcll.backend.domain.graduation.credit.CategoryType;
+import kr.allcll.backend.domain.graduation.credit.CourseEquivalence;
+import kr.allcll.backend.domain.graduation.credit.CourseEquivalenceRepository;
 import kr.allcll.backend.domain.graduation.credit.CourseReplacement;
 import kr.allcll.backend.domain.graduation.credit.CourseReplacementRepository;
 import kr.allcll.backend.domain.graduation.credit.CreditCriterion;
@@ -42,6 +44,7 @@
 import kr.allcll.backend.support.sheet.validation.BalanceRequiredRulesSheetValidator;
 import kr.allcll.backend.support.sheet.validation.ClassicCertCriteriaSheetValidator;
 import kr.allcll.backend.support.sheet.validation.CodingCertCriteriaSheetValidator;
+import kr.allcll.backend.support.sheet.validation.CourseEquivalencesSheetValidator;
 import kr.allcll.backend.support.sheet.validation.CourseReplacementsSheetValidator;
 import kr.allcll.backend.support.sheet.validation.CreditCriteriaSheetValidator;
 import kr.allcll.backend.support.sheet.validation.DoubleCreditCriteriaSheetValidator;
@@ -64,6 +67,7 @@ public class AdminGraduationSyncService {
     private final RequiredCourseRepository requiredCourseRepository;
     private final CreditCriterionRepository creditCriterionRepository;
     private final GraduationSheetProperties graduationSheetProperties;
+    private final CourseEquivalenceRepository courseEquivalenceRepository;
     private final CourseReplacementRepository courseReplacementRepository;
     private final GraduationCertRuleRepository graduationCertRuleRepository;
     private final BalanceRequiredRuleRepository balanceRequiredRuleRepository;
@@ -83,6 +87,7 @@ public void syncGraduationRules() {
         syncDoubleCreditCriteria();
         syncRequiredCourses();
         syncCourseReplacements();
+        syncCourseEquivalences();
 
         syncBalanceRequiredRule();
         syncBalanceRequiredCourseAreaMap();
@@ -179,6 +184,7 @@ private void syncRequiredCourses() {
                 graduationSheetTable.getString(row, "curi_no"),
                 graduationSheetTable.getString(row, "curi_nm"),
                 graduationSheetTable.getString(row, "alt_group"),
+                graduationSheetTable.getString(row, "group_code"),
                 graduationSheetTable.getBoolean(row, "required"),
                 graduationSheetTable.getString(row, "note")
             );
@@ -215,6 +221,25 @@ private void syncCourseReplacements() {
         log.info("[졸업요건 데이터 동기화] 탭 이름={}, {}개 저장 완료", tabKey, courseReplacementList.size());
     }
 
+    private void syncCourseEquivalences() {
+        String tabKey = CourseEquivalencesSheetValidator.TAB_KEY;
+        GraduationSheetTable graduationSheetTable = fetchAndValidate(tabKey);
+
+        List<CourseEquivalence> courseEquivalenceList = new ArrayList<>();
+        for (List<Object> row : graduationSheetTable.getDataRows()) {
+            CourseEquivalence courseEquivalence = new CourseEquivalence(
+                graduationSheetTable.getString(row, "group_code"),
+                graduationSheetTable.getString(row, "curi_no"),
+                graduationSheetTable.getString(row, "curi_nm")
+            );
+            courseEquivalenceList.add(courseEquivalence);
+        }
+
+        courseEquivalenceRepository.deleteAllInBatch();
+        courseEquivalenceRepository.saveAll(courseEquivalenceList);
+
+        log.info("[졸업요건 데이터 동기화] 탭 이름={}, {}개 저장 완료", tabKey, courseEquivalenceList.size());
+    }
 
     private void syncBalanceRequiredRule() {
         String tabKey = BalanceRequiredRulesSheetValidator.TAB_KEY;

src/main/java/kr/allcll/backend/domain/graduation/credit/AcademicBasicPolicy.java

@@ -10,13 +10,14 @@
 public class AcademicBasicPolicy {
 
     private final RequiredCourseResolver requiredCourseResolver;
-    private final CourseReplacementRepository courseReplacementRepository;
+    private final CourseEquivalenceRepository courseEquivalenceRepository;
 
     public boolean isRecentMajorAcademicBasic(CompletedCourse course, CreditCriterion criterion) {
         if (isNotAcademicBasic(course)) {
             return true;
         }
-        String courseName = course.getCuriNm();
+        String curiNm = course.getCuriNm();
+        String curiNo = course.getCuriNo();
         Integer admissionYear = criterion.getAdmissionYear();
         String departmentName = criterion.getDeptNm();
         List<String> academicBasicRequiredCourseNames = requiredCourseResolver.findRequiredCourseNames(
@@ -25,44 +26,33 @@ public boolean isRecentMajorAcademicBasic(CompletedCourse course, CreditCriterio
             CategoryType.ACADEMIC_BASIC
         );
 
-        if (isExistAcademicBasicCourse(academicBasicRequiredCourseNames, courseName)) {
+        if (isExistAcademicBasicCourse(academicBasicRequiredCourseNames, curiNm)) {
             return true;
         }
 
-        return isHaveReplaceCourse(academicBasicRequiredCourseNames, admissionYear, courseName);
+        return isHaveReplaceOrEquivalenceCourse(admissionYear, departmentName, curiNo);
     }
 
     private boolean isExistAcademicBasicCourse(List<String> academicBasicRequiredCourseNames, String courseName) {
         return academicBasicRequiredCourseNames.contains(courseName);
     }
 
-    /*
-    대체된 최신 과목을 들었을 경우를 판별한다.
-    대체된 최신 과목이 없는 경우 false를 반환한다.
-    대체 과목의 예전 과목 명이, 학생의 이수 요건에 없으면 false를 반환한다.
-     */
-    private boolean isHaveReplaceCourse(
-        List<String> academicBasicRequiredCourseNames,
-        Integer admissionYear,
-        String courseName
-    ) {
-        List<CourseReplacement> recentCourse = courseReplacementRepository.findRecentCourse(admissionYear, courseName);
-        if (recentCourse.isEmpty()) {
-            return false;
-        }
-        for (CourseReplacement courseReplacement : recentCourse) {
-            if (academicBasicRequiredCourseNames.contains(courseReplacement.getLegacyCuriNm())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
     private boolean isNotAcademicBasic(CompletedCourse course) {
-        return !isAcademicBasic(course);
+        return !CategoryType.ACADEMIC_BASIC.equals(course.getCategoryType());
     }
 
-    private boolean isAcademicBasic(CompletedCourse course) {
-        return CategoryType.ACADEMIC_BASIC.equals(course.getCategoryType());
+    private boolean isHaveReplaceOrEquivalenceCourse(
+        Integer admissionYear,
+        String departmentName,
+        String curiNo
+    ) {
+        return courseEquivalenceRepository.findGroupCodeByCuriNo(curiNo)
+            .map(groupCode -> requiredCourseResolver.findRequiredCourseInGroup(
+                departmentName,
+                admissionYear,
+                CategoryType.ACADEMIC_BASIC,
+                groupCode
+            ))
+            .orElse(false);
     }
 }

src/main/java/kr/allcll/backend/domain/graduation/credit/CourseEquivalence.java

@@ -0,0 +1,38 @@
+package kr.allcll.backend.domain.graduation.credit;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import kr.allcll.backend.support.entity.BaseEntity;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Table(name = "course_equivalences")
+@Entity
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class CourseEquivalence extends BaseEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    private Long id;
+
+    @Column(name = "group_code", nullable = false)
+    private String groupCode; // 동일과목 그룹 번호
+
+    @Column(name = "curi_no", nullable = false)
+    private String curiNo; // 학수번호
+
+    @Column(name = "curi_nm", nullable = false, length = 255)
+    private String curiNm; // 과목명
+
+    public CourseEquivalence(String groupCode, String curiNo, String curiNm) {
+        this.groupCode = groupCode;
+        this.curiNo = curiNo;
+        this.curiNm = curiNm;
+    }
+}

src/main/java/kr/allcll/backend/domain/graduation/credit/CourseEquivalenceRepository.java

@@ -0,0 +1,14 @@
+package kr.allcll.backend.domain.graduation.credit;
+
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+
+public interface CourseEquivalenceRepository extends JpaRepository<CourseEquivalence, Long> {
+
+    @Query("""
+        select e.groupCode from CourseEquivalence e
+        where e.curiNo = :curiNo
+    """)
+    Optional<String> findGroupCodeByCuriNo(String curiNo);
+}

src/main/java/kr/allcll/backend/domain/graduation/credit/RequiredCourse.java

@@ -48,6 +48,9 @@ public class RequiredCourse extends BaseEntity {
     @Column(name = "alt_group")
     private String altGroup; // 선택 과목 그룹 키
 
+    @Column(name = "group_code")
+    private String groupCode; // 동일 및 대체 과목 그룹 코드
+
     @Column(name = "required", nullable = false)
     private Boolean required; // 검사 대상 여부
 
@@ -63,6 +66,7 @@ public RequiredCourse(
         String curiNo,
         String curiNm,
         String altGroup,
+        String groupCode,
         Boolean required,
         String note
     ) {
@@ -74,6 +78,7 @@ public RequiredCourse(
         this.curiNo = curiNo;
         this.curiNm = curiNm;
         this.altGroup = altGroup;
+        this.groupCode = groupCode;
         this.required = required;
         this.note = note;
     }

src/main/java/kr/allcll/backend/domain/graduation/credit/RequiredCourseRepository.java

@@ -20,4 +20,18 @@ public interface RequiredCourseRepository extends JpaRepository<RequiredCourse,
             and r.categoryType = :categoryType
         """)
     List<RequiredCourse> findRequiredCourses(List<String> deptNms, Integer admissionYear, CategoryType categoryType);
+
+    @Query("""
+            select r from RequiredCourse r
+            where r.deptNm in :deptNms
+            and r.admissionYear = :admissionYear
+            and r.categoryType = :categoryType
+            and r.groupCode = :groupCode
+        """)
+    List<RequiredCourse> findRequiredCoursesByGroupCode(
+        List<String> deptNms,
+        Integer admissionYear,
+        CategoryType categoryType,
+        String groupCode
+    );
 }

src/main/java/kr/allcll/backend/domain/graduation/credit/RequiredCourseResolver.java

@@ -13,6 +13,27 @@ public class RequiredCourseResolver {
     private static final String WILD_CARD_DEPT_NM = "ALL";
     private final RequiredCourseRepository requiredCourseRepository;
 
+    public boolean findRequiredCourseInGroup(
+        String departmentName,
+        Integer admissionYear,
+        CategoryType categoryType,
+        String groupCode
+    ) {
+        List<RequiredCourse> requiredCourseCandidatesWithWildCard =
+            requiredCourseRepository.findRequiredCoursesByGroupCode(
+                List.of(WILD_CARD_DEPT_NM, departmentName),
+                admissionYear,
+                categoryType,
+                groupCode
+            );
+
+        List<RequiredCourse> requiredCoursesWithStatus
+            = getDepartmentRequiredCourses(requiredCourseCandidatesWithWildCard, departmentName);
+
+        return requiredCoursesWithStatus.stream()
+            .anyMatch(RequiredCourse::getRequired);
+    }
+
     public List<String> findRequiredCourseNames(
         String departmentName,
         Integer admissionYear,

src/main/java/kr/allcll/backend/support/sheet/validation/CourseEquivalencesSheetValidator.java

@@ -0,0 +1,41 @@
+package kr.allcll.backend.support.sheet.validation;
+
+import java.util.List;
+import kr.allcll.backend.support.sheet.GraduationSheetTable;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@Component
+@RequiredArgsConstructor
+public class CourseEquivalencesSheetValidator implements GraduationSheetValidator {
+
+    public static final String TAB_KEY = "course-equivalences";
+
+    private static final List<String> REQUIRED_HEADERS = List.of(
+        "group_code",
+        "curi_no",
+        "curi_nm"
+    );
+
+    private final GraduationSheetValidationSupport graduationSheetValidationSupport;
+
+    @Override
+    public String tabKey() {
+        return TAB_KEY;
+    }
+
+    @Override
+    public void validate(GraduationSheetTable sheetTable) {
+        graduationSheetValidationSupport.validateNotEmpty(TAB_KEY, sheetTable);
+        graduationSheetValidationSupport.validateRequiredHeaders(TAB_KEY, sheetTable, REQUIRED_HEADERS);
+
+        List<List<Object>> dataRows = sheetTable.getDataRows();
+        for (int rowIndex = 0; rowIndex < dataRows.size(); rowIndex++) {
+            List<Object> dataRow = dataRows.get(rowIndex);
+
+            graduationSheetValidationSupport.requireString(TAB_KEY, sheetTable, dataRow, rowIndex, "group_code");
+            graduationSheetValidationSupport.requireString(TAB_KEY, sheetTable, dataRow, rowIndex, "curi_no");
+            graduationSheetValidationSupport.requireString(TAB_KEY, sheetTable, dataRow, rowIndex, "curi_nm");
+        }
+    }
+}