feat: #77 지원자 다중 필터링 기능 추가

src/main/kotlin/com/yourssu/scouter/ats/application/domain/applicant/ApplicantController.kt

@@ -59,15 +59,8 @@ class ApplicantController(
         @RequestParam(required = false) state: String?,
         @RequestParam(required = false) semesterId: Long?,
     ): ResponseEntity<List<ReadApplicantResponse>> {
-        val applicantDtos: List<ApplicantDto> = when {
-            !name.isNullOrEmpty() && state.isNullOrEmpty() && semesterId == null -> applicantService.searchByName(name)
-            name.isNullOrEmpty() && !state.isNullOrEmpty() && semesterId == null -> applicantService.filterByState(state)
-            name.isNullOrEmpty() && state.isNullOrEmpty() && semesterId != null -> applicantService.filterBySemester(semesterId)
-
-            else -> applicantService.readAll()
-        }
+        val applicantDtos: List<ApplicantDto> = applicantService.readAllByFilters(name, state, semesterId)
         val responses: List<ReadApplicantResponse> = applicantDtos.map { ReadApplicantResponse.from(it) }
-
         return ResponseEntity.ok(responses)
     }
 

src/main/kotlin/com/yourssu/scouter/ats/business/domain/applicant/ApplicantService.kt

@@ -39,30 +39,22 @@ class ApplicantService(
         return ApplicantDto.from(applicant)
     }
 
-    fun readAll(): List<ApplicantDto> {
-        val applicants: List<Applicant> = applicantReader.readAll().sorted()
-
-        return applicants.map { ApplicantDto.from(it) }
-    }
-
-    fun searchByName(name: String): List<ApplicantDto> {
-        val applicants: List<Applicant> = applicantReader.searchAlByName(name).sorted()
-
-        return applicants.map { ApplicantDto.from(it) }
-    }
-
-    fun filterByState(state: String): List<ApplicantDto> {
-        val applicantState: ApplicantState = ApplicantStateConverter.convertToEnum(state)
-        val applicants: List<Applicant> = applicantReader.filterByState(applicantState).sorted()
-
-        return applicants.map { ApplicantDto.from(it) }
-    }
-
-    fun filterBySemester(semesterId: Long): List<ApplicantDto> {
-        val semester: Semester = semesterReader.readById(semesterId)
-        val applicants: List<Applicant> = applicantReader.filterBySemester(semester).sorted()
-
-        return applicants.map { ApplicantDto.from(it) }
+    fun readAllByFilters(name: String?, state: String?, semesterId: Long?): List<ApplicantDto> {
+        var applicants: List<Applicant> = applicantReader.readAll()
+
+        if (!name.isNullOrEmpty()) {
+            applicants = applicants.filter { it.name.contains(name, ignoreCase = true) }
+        }
+        if (!state.isNullOrEmpty()) {
+            val applicantState: ApplicantState = ApplicantStateConverter.convertToEnum(state)
+            applicants = applicants.filter { it.state == applicantState }
+        }
+        if (semesterId != null) {
+            val semester: Semester = semesterReader.readById(semesterId)
+            applicants = applicants.filter { it.applicationSemester == semester }
+        }
+
+        return applicants.sorted().map { ApplicantDto.from(it) }
     }
 
     fun updateById(command: UpdateApplicantCommand) {

src/main/kotlin/com/yourssu/scouter/ats/business/support/utils/ApplicantStateConverter.kt

@@ -2,13 +2,6 @@ package com.yourssu.scouter.ats.business.support.utils
 
 import com.yourssu.scouter.ats.implement.domain.applicant.ApplicantState
 
-/**
- * - “under-review”                 // 심사 진행 중
- * - “document-rejected”      // 서류 불합
- * - “interview-rejected”       // 면접 불합
- * - “incubating-rejected      // 인큐베이팅 불합
- * - “final-accepted”             // 최종 합격
- */
 object ApplicantStateConverter {
 
     private val stateToString = mapOf(

src/main/kotlin/com/yourssu/scouter/ats/implement/domain/applicant/ApplicantReader.kt

@@ -1,7 +1,6 @@
 package com.yourssu.scouter.ats.implement.domain.applicant
 
 import com.yourssu.scouter.ats.implement.support.exception.ApplicantNotFoundException
-import com.yourssu.scouter.common.implement.domain.semester.Semester
 import org.springframework.stereotype.Component
 import org.springframework.transaction.annotation.Transactional
 
@@ -11,14 +10,15 @@ class ApplicantReader(
     private val applicantRepository: ApplicantRepository,
 ) {
 
-    fun readById(applicantId: Long): Applicant =
-        applicantRepository.findById(applicantId) ?: throw ApplicantNotFoundException("지정한 지원자를 찾을 수 없습니다.")
+    fun readById(applicantId: Long): Applicant {
+        return applicantRepository.findById(applicantId) ?: throw ApplicantNotFoundException("지정한 지원자를 찾을 수 없습니다.")
+    }
+
+    fun readAll(): List<Applicant> {
+        return applicantRepository.findAll()
+    }
 
-    fun readAll(): List<Applicant> = applicantRepository.findAll()
-    fun searchAlByName(name: String): List<Applicant> = applicantRepository.findAllByName(name)
     fun filterByState(applicantState: ApplicantState): List<Applicant> {
         return applicantRepository.findAllByState(applicantState)
     }
-
-    fun filterBySemester(semester: Semester): List<Applicant> = applicantRepository.findAllBySemesterId(semester.id!!)
 }

src/main/kotlin/com/yourssu/scouter/ats/implement/domain/applicant/ApplicantRepository.kt

@@ -6,8 +6,6 @@ interface ApplicantRepository {
     fun saveAll(applicants: List<Applicant>)
     fun findById(applicantId: Long): Applicant?
     fun findAll(): List<Applicant>
-    fun findAllByName(name: String): List<Applicant>
     fun findAllByState(state: ApplicantState): List<Applicant>
-    fun findAllBySemesterId(semesterId: Long): List<Applicant>
     fun deleteById(applicantId: Long)
 }

src/main/kotlin/com/yourssu/scouter/ats/storage/domain/applicant/ApplicantRepositoryImpl.kt

@@ -11,8 +11,9 @@ class ApplicantRepositoryImpl(
     private val jpaApplicantRepository: JpaApplicantRepository,
 ) : ApplicantRepository {
 
-    override fun save(applicant: Applicant): Applicant =
-        jpaApplicantRepository.save(ApplicantEntity.from(applicant)).toDomain()
+    override fun save(applicant: Applicant): Applicant {
+        return jpaApplicantRepository.save(ApplicantEntity.from(applicant)).toDomain()
+    }
 
     override fun saveAll(applicants: List<Applicant>) {
         jpaApplicantRepository.saveAll(applicants.map { ApplicantEntity.from(it) })
@@ -22,16 +23,13 @@ class ApplicantRepositoryImpl(
         return jpaApplicantRepository.findByIdOrNull(applicantId)?.toDomain()
     }
 
-    override fun findAll(): List<Applicant> = jpaApplicantRepository.findAll().map { it.toDomain() }
-
-    override fun findAllByName(name: String): List<Applicant> =
-        jpaApplicantRepository.findAllByName(name).map { it.toDomain() }
-
-    override fun findAllByState(state: ApplicantState): List<Applicant> =
-        jpaApplicantRepository.findAllByState(state).map { it.toDomain() }
+    override fun findAll(): List<Applicant> {
+        return jpaApplicantRepository.findAll().map { it.toDomain() }
+    }
 
-    override fun findAllBySemesterId(semesterId: Long): List<Applicant> =
-        jpaApplicantRepository.findAllByApplicationSemesterId(semesterId).map { it.toDomain() }
+    override fun findAllByState(state: ApplicantState): List<Applicant> {
+        return jpaApplicantRepository.findAllByState(state).map { it.toDomain() }
+    }
 
     override fun deleteById(applicantId: Long) {
         jpaApplicantRepository.deleteById(applicantId)