#178 feat: 개설학과 firebase 적용

data/timetable/build.gradle.kts

@@ -9,4 +9,5 @@ android {
 
 dependencies {
   implementation(projects.domain.timetable)
+  testImplementation(libs.junit4)
 }

data/timetable/src/main/java/com/suwiki/data/timetable/OpenLectureRaw.kt

@@ -0,0 +1,11 @@
+package com.suwiki.data.timetable
+
+data class OpenLectureRaw(
+  val number: Long = 0, // 번호
+  val major: String = "", // 개설학과
+  val grade: Int = 1, // 개설학년
+  val className: String = "", // 과목명
+  val classification: String = "", // 이수 구분
+  val professor: String = "",
+  val time: String = "",
+)

data/timetable/src/main/java/com/suwiki/data/timetable/TimetableUtil.kt

@@ -0,0 +1,58 @@
+package com.suwiki.data.timetable
+
+import com.suwiki.common.model.timetable.Cell
+import com.suwiki.common.model.timetable.TimetableDay
+
+object TimetableUtil {
+  fun parseTimeTableString(input: String): List<Cell> {
+    val cellRegex = """([^(]+)\(([^)]+)\)""".toRegex()
+    val dayPeriodRegex = """([월화수목금토])([\d,]+)""".toRegex()
+
+    val result = input.split("),").flatMap { cellInput ->
+      val sanitizedInput = if (!cellInput.endsWith(")")) "$cellInput)" else cellInput
+      cellRegex.find(sanitizedInput)?.let { cellMatch ->
+        val (location, schedule) = cellMatch.destructured
+        val trimmedLocation = location.trim()
+        dayPeriodRegex.findAll(schedule).flatMap { dayPeriodMatch ->
+          val (day, periods) = dayPeriodMatch.destructured
+          val periodList = periods.split(",").map { it.toInt() }
+
+          periodList.groupConsecutive().map { (start, end) ->
+            Cell(
+              location = trimmedLocation,
+              day = when (day) {
+                "월" -> TimetableDay.MON
+                "화" -> TimetableDay.TUE
+                "수" -> TimetableDay.WED
+                "목" -> TimetableDay.THU
+                "금" -> TimetableDay.FRI
+                "토" -> TimetableDay.SAT
+                else -> throw IllegalArgumentException("Invalid day: $day")
+              },
+              startPeriod = start,
+              endPeriod = end
+            )
+          }
+        }.toList()
+      } ?: emptyList()
+    }
+
+    return result
+  }
+
+  private fun List<Int>.groupConsecutive(): List<Pair<Int, Int>> {
+    if (isEmpty()) return emptyList()
+    val result = mutableListOf<Pair<Int, Int>>()
+    var start = this[0]
+    var prev = start
+    for (i in 1 until size) {
+      if (this[i] != prev + 1) {
+        result.add(start to prev)
+        start = this[i]
+      }
+      prev = this[i]
+    }
+    result.add(start to prev)
+    return result
+  }
+}

data/timetable/src/main/java/com/suwiki/data/timetable/datasource/LocalOpenLectureDataSource.kt

@@ -0,0 +1,18 @@
+package com.suwiki.data.timetable.datasource
+
+import com.suwiki.common.model.timetable.OpenLecture
+import kotlinx.coroutines.flow.Flow
+
+interface LocalOpenLectureDataSource {
+  fun getOpenLectureListVersion(): Flow<Long?>
+
+  suspend fun setOpenLectureListVersion(version: Long)
+
+  fun getOpenLectureList(
+    lectureOrProfessorName: String? = null,
+    major: String? = null,
+    grade: Int? = null
+  ): Flow<List<OpenLecture>>
+
+  suspend fun updateAllLectures(lectures: List<OpenLecture>)
+}

data/timetable/src/main/java/com/suwiki/data/timetable/datasource/RemoteOpenLectureDataSource.kt

@@ -1,13 +1,8 @@
 package com.suwiki.data.timetable.datasource
 
-import com.suwiki.common.model.timetable.OpenLectureData
+import com.suwiki.data.timetable.OpenLectureRaw
 
 interface RemoteOpenLectureDataSource {
-  suspend fun getOpenLectureList(
-    cursorId: Long,
-    size: Long,
-    keyword: String?,
-    major: String?,
-    grade: Int?,
-  ): OpenLectureData
+  suspend fun getOpenLectureListVersion(): Long
+  suspend fun getOpenLectureList(): List<OpenLectureRaw>
 }

data/timetable/src/main/java/com/suwiki/data/timetable/repository/OpenLectureRepositoryImpl.kt

@@ -1,24 +1,85 @@
 package com.suwiki.data.timetable.repository
 
-import com.suwiki.common.model.timetable.OpenLectureData
+import com.suwiki.common.model.timetable.OpenLecture
+import com.suwiki.data.timetable.TimetableUtil
+import com.suwiki.data.timetable.datasource.LocalOpenLectureDataSource
 import com.suwiki.data.timetable.datasource.RemoteOpenLectureDataSource
 import com.suwiki.domain.timetable.repository.OpenLectureRepository
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.map
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.util.Locale
 import javax.inject.Inject
 
 class OpenLectureRepositoryImpl @Inject constructor(
   private val remoteOpenLectureDataSource: RemoteOpenLectureDataSource,
+  private val localOpenLectureDataSource: LocalOpenLectureDataSource,
 ) : OpenLectureRepository {
-  override suspend fun getOpenLectureList(
-    cursorId: Long,
-    size: Long,
-    keyword: String?,
+  override fun getOpenLectureList(
+    lectureOrProfessorName: String?,
+
+
     major: String?,
     grade: Int?,
-  ): OpenLectureData = remoteOpenLectureDataSource.getOpenLectureList(
-    cursorId = cursorId,
-    size = size,
-    keyword = keyword,
-    major = major,
-    grade = grade,
-  )
+  ): Flow<List<OpenLecture>> {
+    return localOpenLectureDataSource.getOpenLectureList(
+      lectureOrProfessorName = lectureOrProfessorName,
+      major = major,
+      grade = grade,
+    )
+  }
+
+  override suspend fun checkNeedUpdate(): Boolean {
+    val localVersion = localOpenLectureDataSource.getOpenLectureListVersion().firstOrNull() ?: return true
+    val remoteVersion = remoteOpenLectureDataSource.getOpenLectureListVersion()
+    return remoteVersion > localVersion
+  }
+
+  override suspend fun updateAllLectures() = coroutineScope {
+    val remoteOpenLectures = async {
+      remoteOpenLectureDataSource.getOpenLectureList().map {
+        OpenLecture(
+          id = it.number,
+          name = it.className,
+          type = it.classification,
+          major = it.major,
+          grade = it.grade,
+          professorName = it.professor,
+          originalCellList = TimetableUtil.parseTimeTableString(it.time),
+        )
+      }
+    }
+
+    val remoteOpenLectureVersion = async {
+      remoteOpenLectureDataSource.getOpenLectureListVersion()
+    }
+
+    localOpenLectureDataSource.updateAllLectures(remoteOpenLectures.await())
+    localOpenLectureDataSource.setOpenLectureListVersion(remoteOpenLectureVersion.await())
+  }
+
+  override suspend fun getLastUpdatedDate(): String? {
+    return try {
+      val version = localOpenLectureDataSource.getOpenLectureListVersion().firstOrNull().toString()
+      if (version.length != 12) {
+        return null
+      }
+
+      val formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmm")
+      val dateTime = LocalDateTime.parse(version, formatter)
+
+      val koreanFormatter = DateTimeFormatter.ofPattern("yyyy년 M월 d일 H시 m분", Locale.KOREAN)
+      dateTime.format(koreanFormatter)
+    } catch (e: Exception) {
+      null
+    }
+  }
+
+  override suspend fun getOpenMajor(): List<String> {
+    return localOpenLectureDataSource.getOpenLectureList().map { list -> list.map { it.major } }.firstOrNull() ?: emptyList()
+  }
 }

domain/timetable/src/main/java/com/suwiki/domain/timetable/repository/OpenLectureRepository.kt

@@ -1,13 +1,20 @@
 package com.suwiki.domain.timetable.repository
 
-import com.suwiki.common.model.timetable.OpenLectureData
+import com.suwiki.common.model.timetable.OpenLecture
+import kotlinx.coroutines.flow.Flow
 
 interface OpenLectureRepository {
-  suspend fun getOpenLectureList(
-    cursorId: Long,
-    size: Long,
-    keyword: String?,
-    major: String?,
-    grade: Int?,
-  ): OpenLectureData
+  fun getOpenLectureList(
+    lectureOrProfessorName: String? = null,
+    major: String? = null,
+    grade: Int? = null,
+  ): Flow<List<OpenLecture>>
+
+  suspend fun checkNeedUpdate(): Boolean
+
+  suspend fun updateAllLectures()
+
+  suspend fun getLastUpdatedDate(): String?
+
+  suspend fun getOpenMajor(): List<String>
 }

domain/timetable/src/main/java/com/suwiki/domain/timetable/usecase/GetOpenLectureListUseCase.kt

@@ -8,22 +8,18 @@ import javax.inject.Inject
 class GetOpenLectureListUseCase @Inject constructor(
   private val openLectureRepository: OpenLectureRepository,
 ) {
-  suspend operator fun invoke(param: Param): Result<OpenLectureData> = runCatchingIgnoreCancelled {
+  operator fun invoke(param: Param) =
     with(param) {
-      openLectureRepository.getOpenLectureList(
-        cursorId = cursorId,
-        size = size,
-        keyword = keyword,
-        major = major,
-        grade = grade,
-      )
+      openLectureRepository
+        .getOpenLectureList(
+          lectureOrProfessorName = lectureOrProfessorName,
+          major = major,
+          grade = grade,
+        )
     }
-  }
 
   data class Param(
-    val cursorId: Long,
-    val size: Long = 20,
-    val keyword: String?,
+    val lectureOrProfessorName: String?,
     val major: String?,
     val grade: Int?,
   )

domain/timetable/src/main/java/com/suwiki/domain/timetable/usecase/UpdateOpenLectureIfNeedUseCase.kt

@@ -0,0 +1,14 @@
+package com.suwiki.domain.timetable.usecase
+
+import com.suwiki.domain.common.runCatchingIgnoreCancelled
+import com.suwiki.domain.timetable.repository.OpenLectureRepository
+import javax.inject.Inject
+
+class UpdateOpenLectureIfNeedUseCase @Inject constructor(
+  private val openLectureRepository: OpenLectureRepository,
+) {
+  suspend operator fun invoke(): Result<Unit> = runCatchingIgnoreCancelled {
+    if(openLectureRepository.checkNeedUpdate().not()) return@runCatchingIgnoreCancelled
+    openLectureRepository.updateAllLectures()
+  }
+}

gradle/libs.versions.toml

@@ -179,6 +179,7 @@ encrypted-datastore-preference-security = { group = "tech.thdev", name = "useful
 firebase-bom = { group = "com.google.firebase", name = "firebase-bom", version.ref = "firebase-bom" }
 firebase-analytics = { group = "com.google.firebase", name = "firebase-analytics-ktx" }
 firebase-crashlytics = { group = "com.google.firebase", name = "firebase-crashlytics-ktx" }
+firebase-database = { group = "com.google.firebase", name = "firebase-database-ktx" }
 
 ted-permission = { group = "io.github.ParkSangGwon", name = "tedpermission-normal", version.ref = "ted-permission" }
 coil = { group = "io.coil-kt", name = "coil", version.ref = "coil" }
@@ -204,7 +205,7 @@ kotlin-test = { group = "org.jetbrains.kotlin", name = "kotlin-test", version.re
 androidx-core = { group = "androidx.test", name = "core", version.ref = "core" }
 
 [bundles]
-firebase = ["firebase-analytics"]
+firebase = ["firebase-analytics", "firebase-database"]
 androidx-lifecycle = ["androidx-lifecycle-runtime-ktx", "androidx-lifecycle-viewmodel-ktx"]
 androidx-navigation = ["navigation-fragment-ktx", "navigation-ui-ktx"]
 coroutine = ["kotlinx-coroutines-android", "kotlinx-coroutines-core"]

local/common/src/androidTest/java/com/suwiki/local/common/TimetableDatabaseMigrate1To2Test.kt

@@ -3,7 +3,7 @@ package com.suwiki.local.common
 import androidx.room.testing.MigrationTestHelper
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.platform.app.InstrumentationRegistry
-import com.suwiki.local.common.database.TimetableDatabase
+import com.suwiki.local.common.database.database.TimetableDatabase
 import com.suwiki.local.common.database.di.DatabaseName
 import com.suwiki.local.common.database.migration.TIMETABLE_MIGRATION_1_2
 import org.junit.Rule

local/common/src/main/java/com/suwiki/local/common/database/converter/OpenLectureConverter.kt

@@ -0,0 +1,20 @@
+package com.suwiki.local.common.database.converter
+
+import androidx.room.TypeConverter
+import com.suwiki.local.common.database.entity.CellEntity
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+class OpenLectureConverter {
+  private val json = Json { ignoreUnknownKeys = true }
+
+  @TypeConverter
+  fun fromCellList(value: List<CellEntity>): String {
+    return json.encodeToString(value)
+  }
+
+  @TypeConverter
+  fun toCellList(value: String): List<CellEntity> {
+    return json.decodeFromString(value)
+  }
+}

local/common/src/main/java/com/suwiki/local/common/database/dao/OpenLectureDao.kt

@@ -0,0 +1,39 @@
+package com.suwiki.local.common.database.dao
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+import androidx.room.Transaction
+import com.suwiki.local.common.database.entity.OpenLectureEntity
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface OpenLectureDao {
+
+  @Query(
+    """
+        SELECT * FROM OpenLectureEntity
+        WHERE (:lectureOrProfessorName IS NULL OR name LIKE '%' || :lectureOrProfessorName || '%' OR professorName LIKE '%' || :lectureOrProfessorName || '%')
+        AND (:major IS NULL OR major LIKE '%' || :major || '%')
+        AND (:grade IS NULL OR grade = :grade)
+    """
+  )
+  fun searchLectures(
+    lectureOrProfessorName: String? = null,
+    major: String? = null,
+    grade: Int? = null
+  ): Flow<List<OpenLectureEntity>>
+
+  @Insert(onConflict = OnConflictStrategy.REPLACE)
+  suspend fun insertLectures(lectures: List<OpenLectureEntity>)
+
+  @Query("DELETE FROM OpenLectureEntity")
+  suspend fun deleteAllLectures()
+
+  @Transaction
+  suspend fun updateAllLectures(lectures: List<OpenLectureEntity>) {
+    deleteAllLectures()
+    insertLectures(lectures)
+  }
+}

local/common/src/main/java/com/suwiki/local/common/database/database/OpenLectureDatabase.kt

@@ -0,0 +1,15 @@
+package com.suwiki.local.common.database.database
+
+import androidx.room.Database
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.suwiki.local.common.database.converter.OpenLectureConverter
+import com.suwiki.local.common.database.dao.OpenLectureDao
+import com.suwiki.local.common.database.entity.OpenLectureEntity
+
+
+@Database(entities = [OpenLectureEntity::class], version = 1)
+@TypeConverters(OpenLectureConverter::class)
+abstract class OpenLectureDatabase : RoomDatabase() {
+  abstract fun openLectureDao(): OpenLectureDao
+}

local/common/src/main/java/com/suwiki/local/common/database/OpenMajorDatabase.kt → local/common/src/main/java/com/suwiki/local/common/database/database/OpenMajorDatabase.kt

@@ -1,4 +1,4 @@
-package com.suwiki.local.common.database
+package com.suwiki.local.common.database.database
 
 import androidx.room.AutoMigration
 import androidx.room.Database