Implement core:config module

feature/schedule/build.gradle.kts

@@ -33,7 +33,9 @@ android {
         jvmTarget = jvm.toString()
     }
 }
-
+kapt {
+    correctErrorTypes = true
+}
 dependencies {
     implementation(libs.androidx.appcompat)
     implementation(libs.material)

feature/schedule/src/main/java/ru/fincode/tsudesk/feature/schedule/data/ScheduleRepositoryImpl.kt

@@ -1,7 +1,6 @@
 package ru.fincode.tsudesk.feature.schedule.data
 
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flow
 import ru.fincode.tsudesk.core.common.model.DataResult
@@ -23,18 +22,29 @@ class ScheduleRepositoryImpl @Inject constructor(
 ) : ScheduleRepository {
 
     override fun observeSchedule(type: ScheduleType): Flow<DataResult<ScheduleEntity>> = flow {
-        val key = when (type) {
-            is ScheduleType.Group -> ScheduleCacheKey.group(type.number)
-            is ScheduleType.Teacher -> ScheduleCacheKey.teacher(type.name)
+        val scheduleKey = type.toCacheKey()
+        val cached = local.observeSchedule(scheduleKey).first()
+        cached?.let {
+            emit(DataResult.Data(it, refreshedFromNetwork = false))
         }
 
-        val cached: ScheduleEntity? = local.observeSchedule(key).first()
-        if (cached != null) {
-            emit(DataResult.Data(cached, refreshedFromNetwork = false))
+        val networkResult = loadSchedule(type)
+        if (networkResult is NetworkResult.Error) {
+            emit(DataResult.Error(networkResult.error.toAppError()))
+            return@flow
         }
 
-        // if (cached?.timestamp != updated.timestamp) { ... }
-        val networkResult: NetworkResult<ScheduleEntity> = when (type) {
+        val networkSchedule = (networkResult as NetworkResult.Success).data
+        local.saveSchedule(scheduleKey, networkSchedule)
+
+        val updated = local.loadSchedule(scheduleKey)
+        if (updated != null && cached?.timestamp != updated.timestamp) {
+            emit(DataResult.Data(updated, refreshedFromNetwork = true))
+        }
+    }
+
+    private suspend fun loadSchedule(type: ScheduleType): NetworkResult<ScheduleEntity> =
+        when (type) {
             is ScheduleType.Group ->
                 remote.loadScheduleByGroup(type.number).map(mapper::invoke)
 
@@ -42,18 +52,4 @@ class ScheduleRepositoryImpl @Inject constructor(
                 remote.loadScheduleByTeacher(type.name).map(mapper::invoke)
         }
 
-        when (networkResult) {
-            is NetworkResult.Success -> {
-                local.saveSchedule(key, networkResult.data)
-            }
-
-            is NetworkResult.Error -> {
-                emit(DataResult.Error(networkResult.error.toAppError()))
-                return@flow
-            }
-        }
-        val updated: ScheduleEntity = local.observeSchedule(key).filterNotNull().first()
-        val refreshedFromNetwork = cached?.timestamp != updated.timestamp
-        emit(DataResult.Data(updated, refreshedFromNetwork))
-    }
 }

feature/schedule/src/main/java/ru/fincode/tsudesk/feature/schedule/domain/model/ScheduleType.kt

@@ -1,6 +1,18 @@
 package ru.fincode.tsudesk.feature.schedule.domain.model
 
+import ru.fincode.tsudesk.feature.schedule.data.local.ScheduleCacheKey
+
 sealed interface ScheduleType {
-    data class Group(val number: String) : ScheduleType
-    data class Teacher(val name: String) : ScheduleType
-}
+
+    fun toCacheKey(): String
+
+    data class Group(val number: String) : ScheduleType {
+        override fun toCacheKey(): String =
+            ScheduleCacheKey.group(number)
+    }
+
+    data class Teacher(val name: String) : ScheduleType {
+        override fun toCacheKey(): String =
+            ScheduleCacheKey.teacher(name)
+    }
+}