분석 리포트 화면 구현 및 발표 분석 리포트 플로우 연동

Prezel/app/build.gradle.kts

@@ -54,6 +54,7 @@ dependencies {
     implementation(projects.featureAnalysisImpl)
     implementation(projects.featureSettingImpl)
     implementation(projects.featureProfileImpl)
+    implementation(projects.featureReportImpl)
 
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.lifecycle.runtime.ktx)

Prezel/core/data/build.gradle.kts

@@ -5,7 +5,6 @@ plugins {
 
 android {
     namespace = "com.team.prezel.core.data"
-    testOptions.unitTests.isIncludeAndroidResources = true
 }
 
 dependencies {
@@ -16,4 +15,5 @@ dependencies {
     implementation(projects.coreNetwork)
 
     implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.kotlinx.datetime)
 }

Prezel/core/data/src/main/java/com/team/prezel/core/data/di/RepositoryModule.kt

@@ -2,10 +2,12 @@ package com.team.prezel.core.data.di
 
 import com.team.prezel.core.data.repository.AuthRepositoryImpl
 import com.team.prezel.core.data.repository.PracticeRepositoryImpl
+import com.team.prezel.core.data.repository.PresentationRepositoryImpl
 import com.team.prezel.core.data.repository.TermsRepositoryImpl
 import com.team.prezel.core.data.repository.UserRepositoryImpl
 import com.team.prezel.core.domain.repository.auth.AuthRepository
 import com.team.prezel.core.domain.repository.practice.PracticeRepository
+import com.team.prezel.core.domain.repository.presentation.PresentationRepository
 import com.team.prezel.core.domain.repository.profile.UserRepository
 import com.team.prezel.core.domain.repository.terms.TermsRepository
 import dagger.Binds
@@ -29,6 +31,10 @@ internal abstract class RepositoryModule {
     @Singleton
     abstract fun bindPracticeRepository(impl: PracticeRepositoryImpl): PracticeRepository
 
+    @Binds
+    @Singleton
+    abstract fun bindPresentationRepository(impl: PresentationRepositoryImpl): PresentationRepository
+
     @Binds
     @Singleton
     abstract fun bindTermsRepository(impl: TermsRepositoryImpl): TermsRepository

Prezel/core/data/src/main/java/com/team/prezel/core/data/error/AppErrorExt.kt

@@ -4,6 +4,7 @@ import com.team.prezel.core.common.error.AppError
 import com.team.prezel.core.common.error.AppException
 import com.team.prezel.core.network.model.ApiException
 import com.team.prezel.core.network.model.ServerErrorCode
+import kotlinx.coroutines.CancellationException
 import java.io.IOException
 
 internal fun <T> Result<T>.mapDomainFailure(): Result<T> =
@@ -14,6 +15,8 @@ internal fun <T> Result<T>.mapDomainFailure(): Result<T> =
 
 private fun Throwable.toDomainThrowable(): Throwable =
     when (this) {
+        is CancellationException -> this
+
         is ApiException ->
             AppException(
                 error = errorCode.toDomainError(),
@@ -50,7 +53,10 @@ private fun ServerErrorCode.toDomainError(): AppError =
         ServerErrorCode.VOICE_ANALYSIS_FAILED,
         -> AppError.SERVER_ERROR
 
-        ServerErrorCode.TERMS_NOT_FOUND -> AppError.NOT_FOUND
+        ServerErrorCode.TERMS_NOT_FOUND,
+        ServerErrorCode.PRESENTATION_NOT_FOUND,
+        ServerErrorCode.ANALYSIS_RESULT_NOT_FOUND,
+        -> AppError.NOT_FOUND
 
         ServerErrorCode.DUPLICATE_NICKNAME -> AppError.DUPLICATE
 

Prezel/core/data/src/main/java/com/team/prezel/core/data/mapper/PracticeMapper.kt

@@ -2,18 +2,10 @@ package com.team.prezel.core.data.mapper
 
 import com.team.prezel.core.model.practice.PracticeRecordingAnalysisResult
 import com.team.prezel.core.model.practice.PracticeRecordingOverallEvaluation
-import com.team.prezel.core.model.practice.PracticeRecordingSpeed
 import com.team.prezel.core.model.practice.PracticeScript
-import com.team.prezel.core.model.presentation.Audience
-import com.team.prezel.core.model.presentation.Category
-import com.team.prezel.core.model.presentation.PresentationExpectedQuestion
-import com.team.prezel.core.model.presentation.PresentationGrowthGraph
-import com.team.prezel.core.model.presentation.PresentationRecordingAnalysisResult
-import com.team.prezel.core.model.presentation.Purpose
-import com.team.prezel.core.model.presentation.Style
+import com.team.prezel.core.model.practice.RecordingSpeed
 import com.team.prezel.core.network.model.practice.AnalyzePracticeRecordingResponse
 import com.team.prezel.core.network.model.practice.PracticeSentenceResponse
-import com.team.prezel.core.network.model.practice.PresentationRecordingAnalysisResponse
 import kotlin.math.roundToInt
 
 internal fun PracticeSentenceResponse.toDomain(): PracticeScript =
@@ -25,68 +17,8 @@ internal fun PracticeSentenceResponse.toDomain(): PracticeScript =
 internal fun AnalyzePracticeRecordingResponse.toDomain(): PracticeRecordingAnalysisResult =
     PracticeRecordingAnalysisResult(
         pronunciationScore = accuracyScore.roundToInt(),
-        speed = speedEvaluation.toPracticeRecordingSpeed(),
-        overallEvaluation = overallEvaluation.toPracticeRecordingOverallEvaluation(),
+        speed = RecordingSpeed.from(value = speedEvaluation),
+        overallEvaluation = PracticeRecordingOverallEvaluation.from(overallEvaluation),
     )
 
-internal fun PresentationRecordingAnalysisResponse.toDomain(): PresentationRecordingAnalysisResult =
-    PresentationRecordingAnalysisResult(
-        presentationId = presentationId,
-        analysisResultId = analysisResultId,
-        name = name,
-        type = type,
-        purpose = purpose,
-        style = style,
-        audience = audience,
-        analysisDate = analysisDate,
-        durationSeconds = durationSeconds,
-        formattedDuration = formattedDuration,
-        spm = spm,
-        speedEval = speedEval,
-        summaryFeedback = summaryFeedback,
-        accuracyScore = accuracyScore,
-        scriptMatchRate = scriptMatchRate,
-        spellErrorCount = spellErrorCount,
-        grammarErrorCount = grammarErrorCount,
-        totalErrorCount = totalErrorCount,
-        growthGraph = growthGraph.map { it.toDomain() },
-        expectedQuestions = expectedQuestions.map { it.toDomain() },
-    )
-
-internal fun Category.toRequestType(): String = name
-
-internal fun Purpose.toRequestPurpose(): String = name
-
-internal fun Style.toRequestStyle(): String = name
-
-internal fun Audience.toRequestAudience(): String = name
-
-internal fun PresentationRecordingAnalysisResponse.GrowthGraph.toDomain(): PresentationGrowthGraph =
-    PresentationGrowthGraph(
-        attempt = attempt,
-        accuracyScore = accuracyScore,
-        scriptMatchRate = scriptMatchRate,
-    )
-
-internal fun PresentationRecordingAnalysisResponse.ExpectedQuestion.toDomain(): PresentationExpectedQuestion =
-    PresentationExpectedQuestion(
-        question = question,
-        answer = answer,
-    )
-
-internal fun String.toPracticeRecordingSpeed(): PracticeRecordingSpeed =
-    when {
-        contains("느려요") -> PracticeRecordingSpeed.SLOW
-        contains("빨라요") -> PracticeRecordingSpeed.FAST
-        else -> PracticeRecordingSpeed.ADEQUATE
-    }
-
-internal fun String.toPracticeRecordingOverallEvaluation(): PracticeRecordingOverallEvaluation =
-    when (this) {
-        "Perfect" -> PracticeRecordingOverallEvaluation.PERFECT
-        "Good" -> PracticeRecordingOverallEvaluation.GOOD
-        "Try" -> PracticeRecordingOverallEvaluation.TRY
-        else -> PracticeRecordingOverallEvaluation.TRY
-    }
-
 private const val PRACTICE_SCRIPT_ID = 0L

Prezel/core/data/src/main/java/com/team/prezel/core/data/mapper/PresentationMapper.kt

@@ -0,0 +1,108 @@
+package com.team.prezel.core.data.mapper
+
+import com.team.prezel.core.model.practice.RecordingSpeed
+import com.team.prezel.core.model.presentation.Audience
+import com.team.prezel.core.model.presentation.Category
+import com.team.prezel.core.model.presentation.ExpectedQuestion
+import com.team.prezel.core.model.presentation.PresentationAnalysisSummary
+import com.team.prezel.core.model.presentation.PresentationGrowthPoint
+import com.team.prezel.core.model.presentation.PresentationInfo
+import com.team.prezel.core.model.presentation.PresentationScriptDetail
+import com.team.prezel.core.model.presentation.PresentationWordDetail
+import com.team.prezel.core.model.presentation.Purpose
+import com.team.prezel.core.model.presentation.ScriptCorrection
+import com.team.prezel.core.model.presentation.Style
+import com.team.prezel.core.model.presentation.WordAnalysisDetail
+import com.team.prezel.core.network.model.presentation.GetPresentationsResponse
+import com.team.prezel.core.network.model.presentation.PresentationExpectedQuestionResponse
+import com.team.prezel.core.network.model.presentation.PresentationGrowthResponse
+import com.team.prezel.core.network.model.presentation.PresentationScriptAnalysisResponse
+import com.team.prezel.core.network.model.presentation.PresentationScriptDetailResponse
+import com.team.prezel.core.network.model.presentation.PresentationSummaryResponse
+import com.team.prezel.core.network.model.presentation.PresentationWordAnalysisResponse
+import com.team.prezel.core.network.model.presentation.PresentationWordDetailResponse
+import kotlinx.datetime.LocalDate
+
+internal fun PresentationSummaryResponse.toDomain(): PresentationAnalysisSummary =
+    PresentationAnalysisSummary(
+        presentationId = presentationId,
+        analysisResultId = analysisResultId,
+        title = name,
+        category = Category.from(value = type),
+        purpose = Purpose.from(value = purpose),
+        style = Style.from(value = style),
+        audience = Audience.from(value = audience),
+        analyzedAt = analysisDate,
+        durationSeconds = durationSeconds,
+        formattedDuration = formattedDuration,
+        spm = spm,
+        speedEvaluation = RecordingSpeed.from(value = speedEval),
+        summaryFeedback = summaryFeedback,
+        accuracyScore = accuracyScore,
+        scriptMatchRate = scriptMatchRate,
+        spellErrorCount = spellErrorCount,
+        grammarErrorCount = grammarErrorCount,
+        totalErrorCount = totalErrorCount,
+        growth = growthGraph.map { item -> item.toDomain() },
+        expectedQuestions = expectedQuestions.map { item -> item.toDomain() },
+        selfFeedback = reviewContent,
+    )
+
+private fun PresentationGrowthResponse.toDomain(): PresentationGrowthPoint =
+    PresentationGrowthPoint(
+        attempt = attempt,
+        accuracyScore = accuracyScore,
+        scriptMatchRate = scriptMatchRate,
+    )
+
+private fun PresentationExpectedQuestionResponse.toDomain(): ExpectedQuestion =
+    ExpectedQuestion(
+        question = question,
+        answer = answer,
+    )
+
+internal fun PresentationScriptDetailResponse.toDomain(): PresentationScriptDetail =
+    PresentationScriptDetail(
+        presentationId = presentationId,
+        audioUrl = audioUrl,
+        originalScript = originalScript,
+        scriptCorrections = scriptDetails.map { item -> item.toDomain() },
+    )
+
+internal fun PresentationScriptAnalysisResponse.toDomain(): ScriptCorrection =
+    ScriptCorrection(
+        errorType = errorType,
+        sentence = sentence,
+        originalText = originalText,
+        correctedText = correctedText,
+        reason = reason,
+    )
+
+internal fun PresentationWordDetailResponse.toDomain(): PresentationWordDetail =
+    PresentationWordDetail(
+        presentationId = presentationId,
+        audioUrl = audioUrl,
+        wordDetails = wordDetails.map { item -> item.toDomain() },
+    )
+
+internal fun PresentationWordAnalysisResponse.toDomain(): WordAnalysisDetail =
+    WordAnalysisDetail(
+        word = word,
+        status = status,
+        description = description,
+        accuracy = accuracy,
+        startTimeMs = startTimeMs,
+        endTimeMs = endTimeMs,
+    )
+
+internal fun GetPresentationsResponse.toDomain(): PresentationInfo =
+    PresentationInfo(
+        id = presentationId,
+        title = title,
+        presentationDate = LocalDate.parse(presentationDate),
+        category = Category.from(value = type),
+        purpose = Purpose.from(value = purpose),
+        style = Style.from(value = style),
+        audience = Audience.from(value = audience),
+        dDay = dday,
+    )

Prezel/core/data/src/main/java/com/team/prezel/core/data/repository/PracticeRepositoryImpl.kt

@@ -2,18 +2,9 @@ package com.team.prezel.core.data.repository
 
 import com.team.prezel.core.data.error.mapDomainFailure
 import com.team.prezel.core.data.mapper.toDomain
-import com.team.prezel.core.data.mapper.toRequestAudience
-import com.team.prezel.core.data.mapper.toRequestPurpose
-import com.team.prezel.core.data.mapper.toRequestStyle
-import com.team.prezel.core.data.mapper.toRequestType
 import com.team.prezel.core.domain.repository.practice.PracticeRepository
 import com.team.prezel.core.model.practice.PracticeRecordingAnalysisResult
 import com.team.prezel.core.model.practice.PracticeScript
-import com.team.prezel.core.model.presentation.Audience
-import com.team.prezel.core.model.presentation.Category
-import com.team.prezel.core.model.presentation.PresentationRecordingAnalysisResult
-import com.team.prezel.core.model.presentation.Purpose
-import com.team.prezel.core.model.presentation.Style
 import com.team.prezel.core.network.datasource.PracticeRemoteDataSource
 import javax.inject.Inject
 
@@ -27,33 +18,6 @@ internal class PracticeRepositoryImpl @Inject constructor(
             response.toDomain()
         }.mapDomainFailure()
 
-    override suspend fun analyzePresentationRecording(
-        name: String,
-        date: String,
-        category: Category,
-        purpose: Purpose,
-        style: Style,
-        audience: Audience,
-        script: String?,
-        scriptFilePath: String?,
-        audioFilePath: String,
-    ): Result<PresentationRecordingAnalysisResult> =
-        runCatching {
-            practiceRemoteDataSource.analyzePresentationRecording(
-                name = name,
-                date = date,
-                type = category.toRequestType(),
-                purpose = purpose.toRequestPurpose(),
-                style = style.toRequestStyle(),
-                audience = audience.toRequestAudience(),
-                script = script,
-                scriptFilePath = scriptFilePath,
-                audioFilePath = audioFilePath,
-            )
-        }.mapCatching { response ->
-            response.toDomain()
-        }.mapDomainFailure()
-
     override suspend fun analyzePracticeRecording(
         recordingFilePath: String,
         referenceText: String,