feat: #34 멤버 상태마다 별도의 목록 조회 및 검색 api 추가 (#41)

* remove: 기존 멤버 관련 컴포넌트 삭제

- controller, service, reader, writer, repository 및 관련 dto 삭제

* feat: 멤버 상태에 따라 멤버 domain 분리

* feat: 상태별 멤버 entity 추가

* feat: 상태별 멤버 목록 조회 및 검색을 위한 repository 메서드 추가

* feat: 상태별 멤버 목록 조회 및 검색을 위한 reader 메서드 추가

* feat: 상태별 멤버 목록 조회 및 검색에 사용할 service 메서드 추가

* feat: 상태별 멤버 목록 조회 및 검색 api 추가

src/main/kotlin/com/yourssu/scouter/hrms/application/domain/member/MemberController.kt

@@ -1,18 +1,12 @@
 package com.yourssu.scouter.hrms.application.domain.member
 
-import com.yourssu.scouter.hrms.business.domain.member.CreateMemberCommand
-import com.yourssu.scouter.hrms.business.domain.member.MemberDto
+import com.yourssu.scouter.hrms.business.domain.member.ActiveMemberDto
+import com.yourssu.scouter.hrms.business.domain.member.GraduatedMemberDto
+import com.yourssu.scouter.hrms.business.domain.member.InactiveMemberDto
 import com.yourssu.scouter.hrms.business.domain.member.MemberService
-import com.yourssu.scouter.hrms.business.domain.member.UpdateMemberCommand
-import jakarta.validation.Valid
-import java.net.URI
+import com.yourssu.scouter.hrms.business.domain.member.WithdrawnMemberDto
 import org.springframework.http.ResponseEntity
-import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.GetMapping
-import org.springframework.web.bind.annotation.PatchMapping
-import org.springframework.web.bind.annotation.PathVariable
-import org.springframework.web.bind.annotation.PostMapping
-import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
 
@@ -21,60 +15,58 @@ class MemberController(
     private val memberService: MemberService,
 ) {
 
-    @PostMapping("/members")
-    fun create(
-        @RequestBody @Valid request: CreateMemberRequest,
-    ): ResponseEntity<Unit> {
-        val command: CreateMemberCommand = request.toCommand()
-        val memberId: Long = memberService.create(command)
-
-        return ResponseEntity.created(URI.create("/members/$memberId")).build()
-    }
-
-    @GetMapping("/members/{memberId}")
-    fun readById(
-        @PathVariable memberId: Long,
-    ): ResponseEntity<ReadMemberResponse> {
-        val memberDto: MemberDto = memberService.readById(memberId)
-        val response = ReadMemberResponse.from(memberDto)
+    @GetMapping("/members/active")
+    fun readAllActive(
+        @RequestParam(required = false) search: String?,
+    ): ResponseEntity<List<ReadActiveMemberResponse>> {
+        val activeMemberDtos: List<ActiveMemberDto> = when {
+            !search.isNullOrEmpty() -> memberService.searchAllActiveByNameOrNickname(search)
+            else -> memberService.readAllActive()
+        }
+        val responses: List<ReadActiveMemberResponse> = activeMemberDtos.map { ReadActiveMemberResponse.from(it) }
 
-        return ResponseEntity.ok(response)
+        return ResponseEntity.ok(responses)
     }
 
-    @GetMapping("/members")
-    fun readAll(
+    @GetMapping("/members/inactive")
+    fun readAllInActive(
         @RequestParam(required = false) search: String?,
-        @RequestParam(required = false) state: String?,
-    ): ResponseEntity<List<ReadMemberResponse>> {
-        val memberDtos: List<MemberDto> = when {
-            !search.isNullOrEmpty() && state.isNullOrEmpty() -> memberService.searchByNameOrNickname(search)
-            search.isNullOrEmpty() && !state.isNullOrEmpty() -> memberService.filterByState(state)
-            else -> memberService.readAll()
+    ): ResponseEntity<List<ReadInactiveMemberResponse>> {
+        val inactiveMemberDtos: List<InactiveMemberDto> = when {
+            !search.isNullOrEmpty() -> memberService.searchAllInactiveByNameOrNickname(search)
+            else -> memberService.readAllInactive()
         }
-
-        val responses: List<ReadMemberResponse> = memberDtos.map { ReadMemberResponse.from(it) }
+        val responses: List<ReadInactiveMemberResponse> = inactiveMemberDtos.map { ReadInactiveMemberResponse.from(it) }
 
         return ResponseEntity.ok(responses)
     }
 
-    @PatchMapping("/members/{memberId}")
-    fun updateById(
-        @PathVariable memberId: Long,
-        @RequestBody @Valid request: UpdateMemberRequest,
-    ): ResponseEntity<Unit> {
-        val command: UpdateMemberCommand = request.toCommand(memberId)
-        memberService.updateById(command)
+    @GetMapping("/members/graduated")
+    fun readAllGraduated(
+        @RequestParam(required = false) search: String?,
+    ): ResponseEntity<List<ReadGraduatedMemberResponse>> {
+        val graduatedMemberDtos: List<GraduatedMemberDto> = when {
+            !search.isNullOrEmpty() -> memberService.searchAllGraduatedByNameOrNickname(search)
+            else -> memberService.readAllGraduated()
+        }
+        val responses: List<ReadGraduatedMemberResponse> =
+            graduatedMemberDtos.map { ReadGraduatedMemberResponse.from(it) }
 
-        return ResponseEntity.ok().build()
+        return ResponseEntity.ok(responses)
     }
 
-    @DeleteMapping("/members/{memberId}")
-    fun deleteById(
-        @PathVariable memberId: Long,
-    ): ResponseEntity<Unit> {
-        memberService.deleteById(memberId)
+    @GetMapping("members/withdrawn")
+    fun readAllWithdrawn(
+        @RequestParam(required = false) search: String?,
+    ): ResponseEntity<List<ReadWithdrawnMemberResponse>> {
+        val withdrawnMemberDtos: List<WithdrawnMemberDto> = when {
+            !search.isNullOrEmpty() -> memberService.searchAllWithdrawnByNameOrNickname(search)
+            else -> memberService.readAllWithdrawn()
+        }
+        val responses: List<ReadWithdrawnMemberResponse> =
+            withdrawnMemberDtos.map { ReadWithdrawnMemberResponse.from(it) }
 
-        return ResponseEntity.noContent().build()
+        return ResponseEntity.ok(responses)
     }
 
     @GetMapping("/members/roles")

src/main/kotlin/com/yourssu/scouter/hrms/application/domain/member/ReadActiveMemberResponse.kt

@@ -0,0 +1,64 @@
+package com.yourssu.scouter.hrms.application.domain.member
+
+import com.fasterxml.jackson.annotation.JsonFormat
+import com.yourssu.scouter.hrms.business.domain.member.ActiveMemberDto
+import com.yourssu.scouter.hrms.business.support.utils.MemberRoleConverter
+import com.yourssu.scouter.hrms.business.support.utils.MemberStateConverter
+import com.yourssu.scouter.hrms.business.support.utils.NicknameConverter
+import java.time.LocalDate
+
+data class ReadActiveMemberResponse(
+
+    val memberId: Long,
+
+    val parts: List<ReadDivisionAndPartInMemberResponse>,
+
+    val role: String,
+
+    val name: String,
+
+    val nickname: String,
+
+    val state: String,
+
+    val email: String,
+
+    val phoneNumber: String,
+
+    val department: String,
+
+    val studentId: String,
+
+    @JsonFormat(pattern = "yyyy.MM.dd")
+    val birthDate: LocalDate,
+
+    @JsonFormat(pattern = "yyyy.MM.dd")
+    val joinDate: LocalDate,
+
+    val membershipFee: Boolean,
+
+    val note: String,
+) {
+
+    companion object {
+        fun from(activeMemberDto: ActiveMemberDto): ReadActiveMemberResponse = ReadActiveMemberResponse(
+            memberId = activeMemberDto.member.id,
+            parts = activeMemberDto.member.parts.map { ReadDivisionAndPartInMemberResponse.from(it) },
+            role = MemberRoleConverter.convertToString(activeMemberDto.member.role),
+            name = activeMemberDto.member.name,
+            nickname = NicknameConverter.combine(
+                nicknameEnglish = activeMemberDto.member.nicknameEnglish,
+                nicknameKorean = activeMemberDto.member.nicknameKorean
+            ),
+            state = MemberStateConverter.convertToString(activeMemberDto.member.state),
+            email = activeMemberDto.member.email,
+            phoneNumber = activeMemberDto.member.phoneNumber,
+            department = activeMemberDto.member.department.name,
+            studentId = activeMemberDto.member.studentId,
+            birthDate = activeMemberDto.member.birthDate,
+            joinDate = activeMemberDto.member.joinDate,
+            membershipFee = activeMemberDto.isMembershipFeePaid,
+            note = activeMemberDto.member.note,
+        )
+    }
+}

src/main/kotlin/com/yourssu/scouter/hrms/application/domain/member/ReadDivisionAndPartInMemberResponse.kt

@@ -0,0 +1,16 @@
+package com.yourssu.scouter.hrms.application.domain.member
+
+import com.yourssu.scouter.common.business.domain.part.PartDto
+
+data class ReadDivisionAndPartInMemberResponse(
+
+    val division: String,
+    val part: String,
+) {
+    companion object {
+        fun from(partDto: PartDto): ReadDivisionAndPartInMemberResponse = ReadDivisionAndPartInMemberResponse(
+            division = partDto.division.name,
+            part = partDto.name,
+        )
+    }
+}

src/main/kotlin/com/yourssu/scouter/hrms/application/domain/member/ReadGraduatedMemberResponse.kt

@@ -0,0 +1,67 @@
+package com.yourssu.scouter.hrms.application.domain.member
+
+import com.fasterxml.jackson.annotation.JsonFormat
+import com.yourssu.scouter.hrms.business.domain.member.GraduatedMemberDto
+import com.yourssu.scouter.hrms.business.support.utils.MemberRoleConverter
+import com.yourssu.scouter.hrms.business.support.utils.MemberStateConverter
+import com.yourssu.scouter.hrms.business.support.utils.NicknameConverter
+import java.time.LocalDate
+
+data class ReadGraduatedMemberResponse(
+
+    val memberId: Long,
+
+    val parts: List<ReadDivisionAndPartInMemberResponse>,
+
+    val role: String,
+
+    val name: String,
+
+    val nickname: String,
+
+    val state: String,
+
+    val email: String,
+
+    val phoneNumber: String,
+
+    val department: String,
+
+    val studentId: String,
+
+    @JsonFormat(pattern = "yyyy.MM.dd")
+    val birthDate: LocalDate,
+
+    @JsonFormat(pattern = "yyyy.MM.dd")
+    val joinDate: LocalDate,
+
+    val activePeriod: ReadSemesterPeriodInMemberResponse,
+
+    val isAdvisorDesired: Boolean,
+
+    val note: String,
+) {
+
+    companion object {
+        fun from(graduatedMemberDto: GraduatedMemberDto): ReadGraduatedMemberResponse = ReadGraduatedMemberResponse(
+            memberId = graduatedMemberDto.member.id,
+            parts = graduatedMemberDto.member.parts.map { ReadDivisionAndPartInMemberResponse.from(it) },
+            role = MemberRoleConverter.convertToString(graduatedMemberDto.member.role),
+            name = graduatedMemberDto.member.name,
+            nickname = NicknameConverter.combine(
+                nicknameEnglish = graduatedMemberDto.member.nicknameEnglish,
+                nicknameKorean = graduatedMemberDto.member.nicknameKorean
+            ),
+            state = MemberStateConverter.convertToString(graduatedMemberDto.member.state),
+            email = graduatedMemberDto.member.email,
+            phoneNumber = graduatedMemberDto.member.phoneNumber,
+            department = graduatedMemberDto.member.department.name,
+            studentId = graduatedMemberDto.member.studentId,
+            birthDate = graduatedMemberDto.member.birthDate,
+            joinDate = graduatedMemberDto.member.joinDate,
+            activePeriod = ReadSemesterPeriodInMemberResponse.from(graduatedMemberDto.activePeriod),
+            isAdvisorDesired = graduatedMemberDto.isAdvisorDesired,
+            note = graduatedMemberDto.member.note,
+        )
+    }
+}