테스트 조회 관련 프로젝션 DTO을 수정한다. (#107)

* fix: modify exam projection

* fix: add solved exam read

Author: earlgrey02

domain/src/main/kotlin/com/gotchai/domain/exam/adapter/in/ExamQueryService.kt

@@ -24,12 +24,12 @@ class ExamQueryService(
     override fun getExams(userId: Long): List<GetExamResult> =
         examQueryPort
             .getExamsWithExamHistoryByUserIdAndIsSolved(userId, null)
-            .map { GetExamResult.of(it.exam, it.examHistory) }
+            .map { GetExamResult.of(it.exam, isSolved = it.examHistory?.isSolved ?: false) }
 
     @Transactional(readOnly = true)
     override fun getMyExams(userId: Long): List<GetMyExamResult> =
         examQueryPort
-            .getExamsWithExamHistoryByUserIdAndIsSolved(userId, true)
+            .getSolvedExamsWithExamHistoryByUserIdAndIsSolved(userId, true)
             .map { GetMyExamResult.of(it.exam, it.examHistory) }
 
     @Transactional(readOnly = true)

domain/src/main/kotlin/com/gotchai/domain/exam/dto/projection/ExamWithExamHistory.kt

@@ -5,5 +5,5 @@ import com.gotchai.domain.exam.entity.ExamHistory
 
 data class ExamWithExamHistory(
     val exam: Exam,
-    val examHistory: ExamHistory
+    val examHistory: ExamHistory?
 )

domain/src/main/kotlin/com/gotchai/domain/exam/dto/projection/SolvedExamWithExamHistory.kt

@@ -0,0 +1,9 @@
+package com.gotchai.domain.exam.dto.projection
+
+import com.gotchai.domain.exam.entity.Exam
+import com.gotchai.domain.exam.entity.ExamHistory
+
+data class SolvedExamWithExamHistory(
+    val exam: Exam,
+    val examHistory: ExamHistory
+)

domain/src/main/kotlin/com/gotchai/domain/exam/dto/result/GetExamResult.kt

@@ -1,7 +1,6 @@
 package com.gotchai.domain.exam.dto.result
 
 import com.gotchai.domain.exam.entity.Exam
-import com.gotchai.domain.exam.entity.ExamHistory
 import java.time.LocalDateTime
 
 data class GetExamResult(
@@ -20,7 +19,7 @@ data class GetExamResult(
     companion object {
         fun of(
             exam: Exam,
-            examHistory: ExamHistory
+            isSolved: Boolean
         ): GetExamResult =
             with(exam) {
                 GetExamResult(
@@ -33,7 +32,7 @@ data class GetExamResult(
                     iconImage = iconImage,
                     coverImage = coverImage,
                     theme = theme,
-                    isSolved = examHistory.isSolved,
+                    isSolved = isSolved,
                     createdAt = createdAt
                 )
             }

domain/src/main/kotlin/com/gotchai/domain/exam/port/out/ExamQueryPort.kt

@@ -1,6 +1,7 @@
 package com.gotchai.domain.exam.port.out
 
 import com.gotchai.domain.exam.dto.projection.ExamWithExamHistory
+import com.gotchai.domain.exam.dto.projection.SolvedExamWithExamHistory
 import com.gotchai.domain.exam.entity.Exam
 
 interface ExamQueryPort {
@@ -13,5 +14,10 @@ interface ExamQueryPort {
         isSolved: Boolean?
     ): List<ExamWithExamHistory>
 
+    fun getSolvedExamsWithExamHistoryByUserIdAndIsSolved(
+        userId: Long,
+        isSolved: Boolean?
+    ): List<SolvedExamWithExamHistory>
+
     fun getExamCount(): Long
 }

storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/adapter/out/ExamQueryAdapter.kt

@@ -1,6 +1,7 @@
 package com.gotchai.storage.rdb.exam.adapter.out
 
 import com.gotchai.domain.exam.dto.projection.ExamWithExamHistory
+import com.gotchai.domain.exam.dto.projection.SolvedExamWithExamHistory
 import com.gotchai.domain.exam.entity.Exam
 import com.gotchai.domain.exam.port.out.ExamQueryPort
 import com.gotchai.storage.rdb.exam.entity.ExamEntity
@@ -26,32 +27,64 @@ class ExamQueryAdapter(
     @ReadOnlyTransactional
     override fun getExams(): List<Exam> = examJpaRepository.findAll().map { it.toExam() }
 
+    @ReadOnlyTransactional
+    override fun getSolvedExamsWithExamHistoryByUserIdAndIsSolved(
+        userId: Long,
+        isSolved: Boolean?
+    ): List<SolvedExamWithExamHistory> {
+        val query =
+            jpql {
+                selectNew<Pair<ExamEntity, ExamHistoryEntity>>(
+                    entity(ExamEntity::class),
+                    entity(ExamHistoryEntity::class)
+                ).from(
+                    entity(ExamEntity::class),
+                    innerJoin(ExamHistoryEntity::class)
+                        .on(
+                            path(ExamHistoryEntity::examId)
+                                .eq(path(ExamEntity::id))
+                                .and(path(ExamHistoryEntity::userId).eq(userId))
+                                .apply { if (isSolved != null) and(path(ExamHistoryEntity::isSolved).eq(isSolved)) }
+                        )
+                )
+            }
+        val pairs = entityManager.createQuery(query, jdslRenderContext).resultList
+
+        return pairs.map { (examEntity, examHistoryEntity) ->
+            SolvedExamWithExamHistory(
+                exam = examEntity.toExam(),
+                examHistory = examHistoryEntity.toExamHistory()
+            )
+        }
+    }
+
     @ReadOnlyTransactional
     override fun getExamsWithExamHistoryByUserIdAndIsSolved(
         userId: Long,
         isSolved: Boolean?
     ): List<ExamWithExamHistory> {
         val query =
             jpql {
-                selectNew<Pair<ExamEntity, ExamHistoryEntity>>(
+                selectNew<Pair<ExamEntity, ExamHistoryEntity?>>(
                     entity(ExamEntity::class),
                     entity(ExamHistoryEntity::class)
                 ).from(
                     entity(ExamEntity::class),
-                    leftJoin(ExamHistoryEntity::class).on(
-                        path(ExamHistoryEntity::examId)
-                            .eq(path(ExamEntity::id))
-                            .and(path(ExamHistoryEntity::userId).eq(userId))
-                            .apply { if (isSolved != null) and(path(ExamHistoryEntity::isSolved).eq(isSolved)) }
-                    )
+                    leftJoin(ExamHistoryEntity::class)
+                        .on(
+                            path(ExamHistoryEntity::examId)
+                                .eq(path(ExamEntity::id))
+                                .and(path(ExamHistoryEntity::userId).eq(userId))
+                                .apply { if (isSolved != null) and(path(ExamHistoryEntity::isSolved).eq(isSolved)) }
+                        )
                 )
             }
         val pairs = entityManager.createQuery(query, jdslRenderContext).resultList
 
         return pairs.map { (examEntity, examHistoryEntity) ->
             ExamWithExamHistory(
                 exam = examEntity.toExam(),
-                examHistory = examHistoryEntity.toExamHistory()
+                examHistory = examHistoryEntity?.toExamHistory()
             )
         }
     }