상위 랭크에 대한 API를 구현한다. (#105)

char-yb · web-flow · commit f6daed557063 · 2025-08-16T18:42:19.000+09:00
* feat: user ranking

* refactor: getUserRanking result

* test: UserControllerTest getUserRanking

* fix: naming
diff --git a/api/src/main/kotlin/com/gotchai/api/presentation/v1/user/UserController.kt b/api/src/main/kotlin/com/gotchai/api/presentation/v1/user/UserController.kt
@@ -0,0 +1,18 @@
+package com.gotchai.api.presentation.v1.user
+
+import com.gotchai.api.global.annotation.ApiV1Controller
+import com.gotchai.api.presentation.v1.user.response.UserRankingResponse
+import com.gotchai.domain.user.port.`in`.UserQueryUseCase
+import org.springframework.security.core.annotation.AuthenticationPrincipal
+import org.springframework.web.bind.annotation.GetMapping
+
+@ApiV1Controller
+class UserController(
+    private val userQueryUseCase: UserQueryUseCase
+) {
+    @GetMapping("/users/ranking")
+    fun getUserRanking(
+        @AuthenticationPrincipal
+        userId: Long
+    ): UserRankingResponse = UserRankingResponse.from(userQueryUseCase.getUserRanking(userId))
+}
diff --git a/api/src/main/kotlin/com/gotchai/api/presentation/v1/user/response/UserRankingResponse.kt b/api/src/main/kotlin/com/gotchai/api/presentation/v1/user/response/UserRankingResponse.kt
@@ -0,0 +1,18 @@
+package com.gotchai.api.presentation.v1.user.response
+
+import com.gotchai.domain.user.dto.result.GetUserRankingResult
+
+data class UserRankingResponse(
+    val name: String,
+    val rating: Double
+) {
+    companion object {
+        fun from(result: GetUserRankingResult) =
+            with(result) {
+                UserRankingResponse(
+                    name = name,
+                    rating = rating
+                )
+            }
+    }
+}
diff --git a/api/src/test/kotlin/com/gotchai/api/presentation/v1/user/UserControllerTest.kt b/api/src/test/kotlin/com/gotchai/api/presentation/v1/user/UserControllerTest.kt
@@ -0,0 +1,39 @@
+package com.gotchai.api.presentation.v1.user
+
+import com.gotchai.api.common.ControllerTest
+import com.gotchai.api.docs.userRankingResponseFields
+import com.gotchai.api.global.dto.ApiResponse
+import com.gotchai.api.presentation.v1.user.response.UserRankingResponse
+import com.gotchai.api.util.document
+import com.gotchai.domain.fixture.ID
+import com.gotchai.domain.fixture.createGetUserRankingResult
+import com.gotchai.domain.user.port.`in`.UserQueryUseCase
+import com.ninjasquad.springmockk.MockkBean
+import io.mockk.every
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
+import org.springframework.test.web.reactive.server.expectBody
+
+@WebMvcTest(UserController::class)
+class UserControllerTest : ControllerTest() {
+    @MockkBean
+    private lateinit var userQueryUseCase: UserQueryUseCase
+
+    init {
+        describe("getUserRanking()는") {
+            every { userQueryUseCase.getUserRanking(ID) } returns createGetUserRankingResult()
+
+            it("상태 코드 200과 UserRankingResponse를 반환한다.") {
+                webClient
+                    .get()
+                    .uri("/api/v1/users/ranking")
+                    .exchange()
+                    .expectStatus()
+                    .isOk
+                    .expectBody<ApiResponse<UserRankingResponse>>()
+                    .document("사용자 랭킹 조회 성공(200)") {
+                        responseBody(userRankingResponseFields)
+                    }
+            }
+        }
+    }
+}
diff --git a/api/src/testFixtures/kotlin/com/gotchai/api/docs/UserDocs.kt b/api/src/testFixtures/kotlin/com/gotchai/api/docs/UserDocs.kt
@@ -0,0 +1,11 @@
+package com.gotchai.api.docs
+
+import com.gotchai.api.presentation.v1.user.response.UserRankingResponse
+import com.gotchai.api.util.desc
+import com.gotchai.api.util.fieldsOf
+
+val userRankingResponseFields =
+    fieldsOf(
+        UserRankingResponse::name desc "사용자 이름",
+        UserRankingResponse::rating desc "상위 퍼센트 (0-100)"
+    )
diff --git a/domain/src/main/kotlin/com/gotchai/domain/exam/port/out/ExamHistoryQueryPort.kt b/domain/src/main/kotlin/com/gotchai/domain/exam/port/out/ExamHistoryQueryPort.kt
@@ -3,6 +3,8 @@ package com.gotchai.domain.exam.port.out
 import com.gotchai.domain.exam.entity.ExamHistory
 
 interface ExamHistoryQueryPort {
+    fun getAllExamHistoriesWithQuizIds(): List<ExamHistory>
+
     fun getExamHistoryByExamIdAndUserId(
         examId: Long,
         userId: Long
@@ -12,4 +14,6 @@ interface ExamHistoryQueryPort {
         examId: Long,
         isSolved: Boolean
     ): List<ExamHistory>
+
+    fun getExamHistories(): List<ExamHistory>
 }
diff --git a/domain/src/main/kotlin/com/gotchai/domain/user/adapter/in/UserQueryService.kt b/domain/src/main/kotlin/com/gotchai/domain/user/adapter/in/UserQueryService.kt
@@ -1,7 +1,45 @@
 package com.gotchai.domain.user.adapter.`in`
 
+import com.gotchai.domain.exam.entity.ExamHistory
+import com.gotchai.domain.exam.port.out.ExamHistoryQueryPort
+import com.gotchai.domain.user.dto.result.GetUserRankingResult
+import com.gotchai.domain.user.exception.ProfileNotFoundException
 import com.gotchai.domain.user.port.`in`.UserQueryUseCase
+import com.gotchai.domain.user.port.out.ProfileQueryPort
 import org.springframework.stereotype.Service
 
 @Service
-class UserQueryService : UserQueryUseCase
+class UserQueryService(
+    private val profileQueryPort: ProfileQueryPort,
+    private val examHistoryQueryPort: ExamHistoryQueryPort
+) : UserQueryUseCase {
+    override fun getUserRanking(userId: Long): GetUserRankingResult {
+        val profile = profileQueryPort.getProfileByUserId(userId) ?: throw ProfileNotFoundException()
+        val allHistories = examHistoryQueryPort.getAllExamHistoriesWithQuizIds()
+
+        val rating = calculateUserRating(userId, allHistories)
+        return GetUserRankingResult.of(profile, rating)
+    }
+
+    private fun calculateUserRating(
+        userId: Long,
+        allHistories: List<ExamHistory>
+    ): Double {
+        if (allHistories.isEmpty() || !allHistories.any { it.userId == userId }) return 100.0
+
+        val userScores =
+            allHistories
+                .groupBy { it.userId }
+                .mapValues { (_, histories) ->
+                    val totalCorrect = histories.sumOf { it.correctAnswerCount }
+                    val totalQuizzes = histories.sumOf { it.quizIds.size }
+                    if (totalQuizzes == 0) 0.0 else totalCorrect.toDouble() / totalQuizzes.toDouble()
+                }
+
+        val userScore = userScores[userId] ?: return 100.0
+        if (userScores.size == 1) return 0.0
+
+        val usersWithHigherScore = userScores.values.count { it > userScore }
+        return (usersWithHigherScore.toDouble() / userScores.size.toDouble()) * 100
+    }
+}
diff --git a/domain/src/main/kotlin/com/gotchai/domain/user/dto/result/GetUserRankingResult.kt b/domain/src/main/kotlin/com/gotchai/domain/user/dto/result/GetUserRankingResult.kt
@@ -0,0 +1,18 @@
+package com.gotchai.domain.user.dto.result
+
+import com.gotchai.domain.user.entity.Profile
+
+data class GetUserRankingResult(
+    val name: String,
+    val rating: Double
+) {
+    companion object {
+        fun of(
+            profile: Profile,
+            rating: Double
+        ) = GetUserRankingResult(
+            name = profile.nickname,
+            rating = rating
+        )
+    }
+}
diff --git a/domain/src/main/kotlin/com/gotchai/domain/user/port/in/UserQueryUseCase.kt b/domain/src/main/kotlin/com/gotchai/domain/user/port/in/UserQueryUseCase.kt
@@ -1,3 +1,7 @@
 package com.gotchai.domain.user.port.`in`
 
-interface UserQueryUseCase
+import com.gotchai.domain.user.dto.result.GetUserRankingResult
+
+interface UserQueryUseCase {
+    fun getUserRanking(userId: Long): GetUserRankingResult
+}
diff --git a/domain/src/testFixtures/kotlin/com/gotchai/domain/fixture/UserFixture.kt b/domain/src/testFixtures/kotlin/com/gotchai/domain/fixture/UserFixture.kt
@@ -1,5 +1,6 @@
 package com.gotchai.domain.fixture
 
+import com.gotchai.domain.user.dto.result.GetUserRankingResult
 import com.gotchai.domain.user.entity.*
 import java.time.LocalDateTime
 
@@ -52,3 +53,12 @@ fun createUserSocial(
         provider = provider,
         createdAt = createdAt
     )
+
+fun createGetUserRankingResult(
+    name: String = NICKNAME,
+    rating: Double = 25.0
+): GetUserRankingResult =
+    GetUserRankingResult(
+        name = name,
+        rating = rating
+    )
diff --git a/storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/adapter/out/ExamHistoryQueryAdapter.kt b/storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/adapter/out/ExamHistoryQueryAdapter.kt
@@ -10,6 +10,13 @@ import com.gotchai.storage.rdb.global.annotation.ReadOnlyTransactional
 class ExamHistoryQueryAdapter(
     private val examHistoryJpaRepository: ExamHistoryJpaRepository
 ) : ExamHistoryQueryPort {
+    @ReadOnlyTransactional
+    override fun getExamHistories(): List<ExamHistory> = examHistoryJpaRepository.findAll().map { it.toExamHistory() }
+
+    @ReadOnlyTransactional
+    override fun getAllExamHistoriesWithQuizIds(): List<ExamHistory> =
+        examHistoryJpaRepository.findAllWithQuizIds().map { it.toExamHistory() }
+
     @ReadOnlyTransactional
     override fun getExamHistoryByExamIdAndUserId(
         examId: Long,
diff --git a/storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/repository/ExamHistoryJpaRepository.kt b/storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/repository/ExamHistoryJpaRepository.kt
@@ -2,15 +2,27 @@ package com.gotchai.storage.rdb.exam.repository
 
 import com.gotchai.storage.rdb.exam.entity.ExamHistoryEntity
 import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
 
 interface ExamHistoryJpaRepository : JpaRepository<ExamHistoryEntity, Long> {
     fun findByExamIdAndUserId(
         examId: Long,
         userId: Long
     ): ExamHistoryEntity?
 
+    @Query("SELECT e FROM ExamHistoryEntity e WHERE e.examId = :examId AND e.isSolved = :isSolved")
     fun findAllByExamIdAndIsSolved(
-        examId: Long,
-        isSolved: Boolean
+        @Param("examId") examId: Long,
+        @Param("isSolved") isSolved: Boolean
+    ): List<ExamHistoryEntity>
+
+    @Query("SELECT e FROM ExamHistoryEntity e WHERE e.userId = :userId AND e.isSolved = :isSolved")
+    fun findAllByUserIdAndIsSolved(
+        @Param("userId") userId: Long,
+        @Param("isSolved") isSolved: Boolean
     ): List<ExamHistoryEntity>
+
+    @Query("SELECT e FROM ExamHistoryEntity e JOIN FETCH e.quizIds")
+    fun findAllWithQuizIds(): List<ExamHistoryEntity>
 }
