추억 저장소 db에 의존하도록 마이그레이션

core/data/src/main/java/com/teampatch/core/data/di/DataSingletonModule.kt

@@ -3,10 +3,10 @@ package com.teampatch.core.data.di
 import com.teampatch.core.data.entity.TokenManagerImpl
 import com.teampatch.core.data.repository.AnswerRepositoryImpl
 import com.teampatch.core.data.repository.AppManagementRepositoryImpl
-import com.teampatch.core.data.repository.MemoryCardRepositoryImpl
 import com.teampatch.core.data.repository.TodoOfflineRepositoryImpl
 import com.teampatch.core.data.repository.local.LocalAuthenticationRepositoryImpl
 import com.teampatch.core.data.repository.local.LocalGroupManagementRepositoryImpl
+import com.teampatch.core.data.repository.local.LocalMemoryCardRepositoryImpl
 import com.teampatch.core.data.repository.local.LocalQuestionRepositoryImpl
 import com.teampatch.core.data.repository.local.LocalUserRepositoryImpl
 import com.teampatch.core.domain.entity.TokenManager
@@ -34,7 +34,7 @@ internal abstract class DataSingletonModule {
 
     @Binds
     abstract fun bindsMemoryCardRepository(
-        memoryCardRepositoryImpl: MemoryCardRepositoryImpl,
+        localMemoryCardRepositoryImpl: LocalMemoryCardRepositoryImpl,
     ): MemoryCardRepository
 
     @Binds

core/data/src/main/java/com/teampatch/core/data/mapper/MemoryCardMapper.kt

@@ -0,0 +1,22 @@
+package com.teampatch.core.data.mapper
+
+import com.harmony.core.database.LOCAL_DB_DATE_TIME_FORMATTER
+import com.harmony.core.database.model.MemoryCardEntity
+import com.teampatch.core.domain.model.MemoryCard
+import java.time.LocalDateTime
+
+fun MemoryCardEntity.toDomain(
+    writerName: String,
+): MemoryCard = MemoryCard(
+    id = id.toString(),
+    writerTitle = "",
+    writerName = writerName,
+    text = title,
+    imageUrl = imageUrl,
+    dateTime = LocalDateTime.parse(
+        /* text = */
+        modifiedAt,
+        /* formatter = */
+        LOCAL_DB_DATE_TIME_FORMATTER
+    )
+)

core/data/src/main/java/com/teampatch/core/data/repository/local/LocalMemoryCardRepositoryImpl.kt

@@ -0,0 +1,63 @@
+package com.teampatch.core.data.repository.local
+
+import android.util.Log
+import androidx.paging.PagingData
+import com.harmony.core.database.dao.MemoryCardDao
+import com.harmony.core.database.dao.UserDao
+import com.teampatch.core.data.mapper.toDomain
+import com.teampatch.core.domain.fake.FakeMemoryCardQuestion
+import com.teampatch.core.domain.model.MemoryCard
+import com.teampatch.core.domain.model.MemoryCardQuestion
+import com.teampatch.core.domain.repository.MemoryCardRepository
+import java.io.InputStream
+import javax.inject.Inject
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.flatMapLatest
+import kotlinx.coroutines.flow.map
+
+internal class LocalMemoryCardRepositoryImpl @Inject constructor(
+    private val memoryCardDao: MemoryCardDao,
+    private val userDao: UserDao,
+) : MemoryCardRepository {
+
+    override suspend fun addCommunication(
+        memoryCardId: String,
+        question: String,
+        audioFile: InputStream,
+    ) {
+    }
+
+    override suspend fun getQuestionMessage(memoryCardId: String): MemoryCardQuestion = FakeMemoryCardQuestion().get()
+
+    override fun getMemoryCards(): Flow<PagingData<MemoryCard>> {
+        return memoryCardDao.getAllMemoryStorage().map { memoryCardEntities ->
+            memoryCardEntities.mapNotNull { memoryCardEntity ->
+                val writerUserInfo = userDao.getUserById(memoryCardEntity.writtenUid).firstOrNull()
+
+                if (writerUserInfo == null) {
+                    Log.e(TAG, "function: getMemoryCards(), data: writerUserInfo is null")
+                    return@mapNotNull null
+                }
+
+                memoryCardEntity.toDomain(writerUserInfo.name)
+            }
+                .let {
+                    PagingData.from(it)
+                }
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    override fun getMemoryCardById(memoryCardId: String): Flow<MemoryCard> = memoryCardDao.getMemoryStorageById(memoryCardId.toLong())
+        .flatMapLatest { memoryCardEntity ->
+            userDao.getUserById(memoryCardEntity.writtenUid).map { writerUserInfo ->
+                memoryCardEntity.toDomain(writerUserInfo.name)
+            }
+        }
+
+    companion object {
+        private const val TAG = "MemoryCardRepositoryImpl"
+    }
+}

core/database/build.gradle.kts

@@ -23,6 +23,8 @@ dependencies {
     // optional - Paging 3 Integration
     implementation(libs.androidx.room.paging)
 
+    implementation(libs.squareup.moshi.kotlin)
+
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)

core/database/src/main/java/com/harmony/core/database/HarmonyDatabase.kt

@@ -2,11 +2,15 @@ package com.harmony.core.database
 
 import androidx.room.Database
 import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import com.harmony.core.database.converters.SetStringTypeTypeConverter
 import com.harmony.core.database.dao.GroupDao
+import com.harmony.core.database.dao.MemoryCardDao
 import com.harmony.core.database.dao.QuestionDao
 import com.harmony.core.database.dao.TodoDao
 import com.harmony.core.database.dao.UserDao
 import com.harmony.core.database.model.GroupEntity
+import com.harmony.core.database.model.MemoryCardEntity
 import com.harmony.core.database.model.QuestionCommentEntity
 import com.harmony.core.database.model.QuestionEntity
 import com.harmony.core.database.model.TodoEntity
@@ -18,15 +22,22 @@ import com.harmony.core.database.model.UserEntity
         UserEntity::class,
         GroupEntity::class,
         QuestionEntity::class,
-        QuestionCommentEntity::class
+        QuestionCommentEntity::class,
+        MemoryCardEntity::class
     ],
     version = 1
 )
+@TypeConverters(
+    value = [
+        SetStringTypeTypeConverter::class
+    ]
+)
 internal abstract class HarmonyDatabase : RoomDatabase() {
     abstract fun todoDao(): TodoDao
     abstract fun userDao(): UserDao
     abstract fun groupDao(): GroupDao
     abstract fun questionDao(): QuestionDao
+    abstract fun memoryCardDao(): MemoryCardDao
 
     companion object {
         internal const val DB_NAME = "harmony.db"

core/database/src/main/java/com/harmony/core/database/converters/RoomTypeConverter.kt

@@ -0,0 +1,6 @@
+package com.harmony.core.database.converters
+
+internal abstract class RoomTypeConverter<T> {
+    abstract fun fromObjectToJson(value: T): String
+    abstract fun fromJsonToObject(value: String): T
+}

core/database/src/main/java/com/harmony/core/database/converters/SetStringTypeTypeConverter.kt

@@ -0,0 +1,19 @@
+package com.harmony.core.database.converters
+
+import androidx.room.TypeConverter
+import com.squareup.moshi.JsonAdapter
+import com.squareup.moshi.Moshi
+
+internal class SetStringTypeTypeConverter : RoomTypeConverter<Set<String>>() {
+
+    @TypeConverter
+    override fun fromObjectToJson(value: Set<String>): String = adapter.toJson(value)
+
+    @TypeConverter
+    override fun fromJsonToObject(value: String): Set<String> = adapter.fromJson(value)!!
+
+    companion object {
+        private val moshi: Moshi = Moshi.Builder().build()
+        private val adapter: JsonAdapter<Set<String>> = moshi.adapter<Set<String>>(Set::class.java)
+    }
+}

core/database/src/main/java/com/harmony/core/database/dao/MemoryCardDao.kt

@@ -0,0 +1,27 @@
+package com.harmony.core.database.dao
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.Query
+import androidx.room.Update
+import com.harmony.core.database.model.MemoryCardEntity
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface MemoryCardDao {
+
+    @Query("SELECT * FROM memory_card")
+    fun getAllMemoryStorage(): Flow<List<MemoryCardEntity>>
+
+    @Query("SELECT * FROM memory_card WHERE id = :id")
+    fun getMemoryStorageById(id: Long): Flow<MemoryCardEntity>
+
+    @Insert(MemoryCardEntity::class)
+    fun insertMemoryStorage(memoryCardEntity: MemoryCardEntity)
+
+    @Update(MemoryCardEntity::class)
+    fun updateMemoryStorage(memoryCardEntity: MemoryCardEntity)
+
+    @Query("DELETE FROM memory_card WHERE id = :id")
+    fun deleteMemoryStorageById(id: Long)
+}

core/database/src/main/java/com/harmony/core/database/dao/UserDao.kt

@@ -19,7 +19,7 @@ interface UserDao {
     @Query("SELECT * FROM user WHERE uid = :uid")
     fun getUserById(uid: Long): Flow<UserEntity>
 
-    @Query("SELECT * FROM user WHERE groupId = :id")
+    @Query("SELECT * FROM user WHERE group_id = :id")
     fun getUserByGroupId(id: Long): Flow<List<UserEntity>>
 
     @Query("SELECT * FROM user WHERE sns_id = :id")

core/database/src/main/java/com/harmony/core/database/di/DatabaseModule.kt

@@ -6,11 +6,14 @@ import androidx.room.RoomDatabase.Callback
 import androidx.sqlite.db.SupportSQLiteDatabase
 import com.harmony.core.database.HarmonyDatabase
 import com.harmony.core.database.dao.GroupDao
+import com.harmony.core.database.dao.MemoryCardDao
 import com.harmony.core.database.dao.QuestionDao
 import com.harmony.core.database.dao.TodoDao
 import com.harmony.core.database.dao.UserDao
+import com.harmony.core.database.model.preload.MemoryCardPreloadData
 import com.harmony.core.database.model.preload.QuestionPreloadData
 import com.harmony.core.database.model.preload.TodoPreloadData
+import com.harmony.core.database.model.preload.UserPreloadData
 import dagger.Module
 import dagger.Provides
 import dagger.hilt.InstallIn
@@ -32,7 +35,9 @@ internal object DatabaseModule {
                 super.onCreate(db)
                 listOf(
                     QuestionPreloadData(),
-                    TodoPreloadData()
+                    TodoPreloadData(),
+                    UserPreloadData(),
+                    MemoryCardPreloadData()
                 )
                     .forEach { it.insertPreloadData(db) }
             }
@@ -66,4 +71,9 @@ internal object DatabaseModule {
     fun providesQuestionDao(
         harmonyDatabase: HarmonyDatabase,
     ): QuestionDao = harmonyDatabase.questionDao()
+
+    @Provides
+    fun providesMemoryCardDao(
+        harmonyDatabase: HarmonyDatabase,
+    ): MemoryCardDao = harmonyDatabase.memoryCardDao()
 }

core/database/src/main/java/com/harmony/core/database/model/MemoryCardEntity.kt

@@ -0,0 +1,34 @@
+package com.harmony.core.database.model
+
+import androidx.room.ColumnInfo
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.PrimaryKey
+
+@Entity(
+    tableName = "memory_card",
+    foreignKeys = [
+        ForeignKey(
+            entity = QuestionEntity::class,
+            parentColumns = ["id"],
+            childColumns = ["question_id"]
+        ),
+        ForeignKey(
+            entity = UserEntity::class,
+            parentColumns = ["uid"],
+            childColumns = ["written_uid"]
+        )
+    ]
+)
+data class MemoryCardEntity(
+    @PrimaryKey(autoGenerate = true) val id: Long? = null,
+    @ColumnInfo("question_id") val questionId: Long,
+    @ColumnInfo("written_uid") val writtenUid: Long,
+    @ColumnInfo("title") val title: String,
+    @ColumnInfo("content") val content: String,
+    @ColumnInfo("created_at") val createdAt: String,
+    @ColumnInfo("modified_at") val modifiedAt: String,
+    @ColumnInfo("image_uri") val imageUri: String?,
+    @ColumnInfo("image_url") val imageUrl: String?,
+    @ColumnInfo("tags") val tags: Set<String>,
+)

core/database/src/main/java/com/harmony/core/database/model/UserEntity.kt

@@ -7,10 +7,10 @@ import androidx.room.PrimaryKey
 @Entity(tableName = "user")
 data class UserEntity(
     @PrimaryKey(autoGenerate = true) val uid: Long? = null,
-    @ColumnInfo(name = "groupId") val groupId: Long?,
+    @ColumnInfo(name = "group_id") val groupId: Long?,
     @ColumnInfo(name = "name") val name: String,
     @ColumnInfo(name = "relation") val relation: String,
-    @ColumnInfo(name = "profileImageUri") val profileImageUri: String?,
+    @ColumnInfo(name = "profile_image_uri") val profileImageUri: String?,
     @ColumnInfo(name = "role") val role: String,
     @ColumnInfo(name = "sns_id") val snsId: String,
     @ColumnInfo(name = "is_me") val isMe: Boolean,