Merge pull request #46 from f-lab-edu/feature/feature#44_search

feature#44 search 검색 후 화면 개발

Author: soochan8

core/database/src/main/java/com/chan/database/AppDatabase.kt

@@ -42,6 +42,36 @@ val MIGRATION_13_14 = object : Migration(13, 14) {
     }
 }
 
+val MIGRATION_14_15 = object : Migration(14, 15) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("""
+            CREATE TABLE IF NOT EXISTS `products` (
+                `productId` TEXT NOT NULL, 
+                `productName` TEXT NOT NULL, 
+                `brandName` TEXT NOT NULL, 
+                `imageUrl` TEXT NOT NULL, 
+                `originalPrice` INTEGER NOT NULL, 
+                `discountPercent` INTEGER NOT NULL, 
+                `discountPrice` INTEGER NOT NULL, 
+                `tags` TEXT NOT NULL, 
+                `reviewRating` REAL NOT NULL, 
+                `reviewCount` INTEGER NOT NULL, 
+                `categoryIds` TEXT NOT NULL, 
+                PRIMARY KEY(`productId`)
+            )
+        """.trimIndent())
+
+        db.execSQL("""
+            CREATE TABLE IF NOT EXISTS `category` (
+                `id` TEXT NOT NULL, 
+                `name` TEXT NOT NULL, 
+                `parentCategoryId` TEXT, 
+                PRIMARY KEY(`id`)
+            )
+        """.trimIndent())
+    }
+}
+
 @Database(
     entities = [HomeBannerEntity::class, ProductEntity::class, ProductDetailEntity::class, UserEntity::class, SearchHistoryEntity::class, CommonProductEntity::class, CommonCategoryEntity::class],
     version = 15,

core/database/src/main/java/com/chan/database/DatabaseModule.kt

@@ -37,7 +37,8 @@ object DatabaseModule {
     fun provideDatabase(
         @ApplicationContext context: Context,
         productDao: Provider<ProductDao>,
-        productsDao: Provider<ProductsDao>
+        productsDao: Provider<ProductsDao>,
+        categoryDao: Provider<CategoryDao>,
     ): AppDatabase {
         return Room.databaseBuilder(
             context,
@@ -49,12 +50,13 @@ object DatabaseModule {
                     super.onCreate(db)
                     CoroutineScope(Dispatchers.IO).launch {
                         insertAllProducts(context, productsDao.get())
-                        products(context, productDao.get())
+                        insertAllCategories(context, categoryDao.get())
+//                        products(context, productDao.get())
                     }
                 }
             }
         )
-            .addMigrations(MIGRATION_13_14)
+            .addMigrations(MIGRATION_13_14, MIGRATION_14_15)
             .build()
     }
 
@@ -82,6 +84,18 @@ object DatabaseModule {
         productsDao.insertAllProducts(products)
     }
 
+    private suspend fun insertAllCategories(context: Context, categoryDao: CategoryDao) {
+        val fileName = "category.json"
+        val jsonString = context.assets
+            .open(fileName)
+            .bufferedReader()
+            .use { it.readText() }
+
+        val listType = object : TypeToken<List<CommonCategoryEntity>>() {}.type
+        val products: List<CommonCategoryEntity> = Gson().fromJson(jsonString, listType)
+        categoryDao.insertAllCategories(products)
+    }
+
     @Provides
     fun provideHomeBannerDao(db: AppDatabase): HomeBannerDao =
         db.homeBannerDao()

core/database/src/main/java/com/chan/database/dao/ProductDao.kt

@@ -6,6 +6,7 @@ import androidx.room.OnConflictStrategy
 import androidx.room.Query
 import com.chan.database.dto.CategoryDetailTabsDto
 import com.chan.database.dto.CategoryTabDto
+import com.chan.database.dto.FilterCategoriesDto
 import com.chan.database.entity.ProductEntity
 
 @Dao
@@ -43,7 +44,7 @@ interface ProductDao {
     }
 
     //세일 상품 가져오기
-    suspend fun getSaleProducts(limit : Int): List<ProductEntity.Categories.SubCategories.Products> {
+    suspend fun getSaleProducts(limit: Int): List<ProductEntity.Categories.SubCategories.Products> {
         return getAll()
             .flatMap { it.categories }
             .flatMap { it.subCategories }
@@ -52,38 +53,4 @@ interface ProductDao {
             .shuffled()
             .take(limit)
     }
-
-    // 동일한 상위 카테고리에 속한 모든 하위 카테고리 정보(id, name) 가져오기
-    suspend fun getSiblingSubCategories(subCategoryId: String): List<CategoryDetailTabsDto> {
-        return getAll()
-            .flatMap { it.categories }
-            .firstOrNull { category ->
-                category.subCategories.any { it.categoryId == subCategoryId }
-            }
-            ?.subCategories
-            ?.map { CategoryDetailTabsDto(categoryId = it.categoryId, categoryName = it.categoryName) }
-            ?: emptyList()
-    }
-
-    //해당 카테고리에 따른 리스트 상품 가져오기
-    suspend fun getProductsBySubCategoryId(subCategoryId: String): List<ProductEntity.Categories.SubCategories.Products> {
-        return getAll()
-            .flatMap { it.categories }
-            .flatMap { it.subCategories }
-            .find { it.categoryId == subCategoryId }
-            ?.products
-            ?: emptyList()
-    }
-
-    // 상품 이름으로 검색하기
-    suspend fun searchProductsByName(query: String): List<ProductEntity.Categories.SubCategories.Products> {
-        if (query.isBlank()) {
-            return emptyList()
-        }
-        return getAll()
-            .flatMap { it.categories }
-            .flatMap { it.subCategories }
-            .flatMap { it.products }
-            .filter { it.productName.contains(query, ignoreCase = true) }
-    }
 }

core/database/src/main/java/com/chan/database/dao/ProductsDao.kt

@@ -29,4 +29,8 @@ interface ProductsDao {
 
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     suspend fun insertAllProducts(products: List<CommonProductEntity>)
+
+    //검색어가 포함된 상품
+    @Query("SELECT * FROM products WHERE productName LIKE '%' || :search || '%'")
+    suspend fun searchProductsByName(search: String) : List<CommonProductEntity>
 }

core/database/src/main/java/com/chan/database/dto/FilterCategoriesDto.kt

@@ -0,0 +1,12 @@
+package com.chan.database.dto
+
+data class FilterCategoriesDto(
+    val categoryId: String,
+    val name: String,
+    val subCategories: List<SubCategoryDto>
+) {
+    data class SubCategoryDto(
+        val subCategoryId: String,
+        val subCategoryName: String,
+    )
+}

feature/search/src/main/java/com/chan/search/data/mappers/CategoryFilterMapper.kt

@@ -0,0 +1,13 @@
+package com.chan.search.data.mappers
+
+import com.chan.database.entity.CommonCategoryEntity
+import com.chan.search.domain.model.CategoryVO
+
+fun CommonCategoryEntity.toCategoryVO(): CategoryVO =
+    CategoryVO(
+        id = id,
+        name = name
+    )
+
+
+

feature/search/src/main/java/com/chan/search/data/mappers/SearchToDomainMapper.kt

@@ -1,10 +1,16 @@
 package com.chan.search.data.mappers
 
+import com.chan.android.model.ProductModel
+import com.chan.database.dto.FilterCategoriesDto
+import com.chan.database.entity.CommonProductEntity
 import com.chan.database.entity.ProductEntity
 import com.chan.database.entity.search.SearchHistoryEntity
 import com.chan.domain.ProductVO
+import com.chan.domain.ProductsVO
+import com.chan.search.domain.model.FilterCategoriesVO
 import com.chan.search.domain.model.SearchHistoryVO
-import com.chan.search.ui.model.SearchHistoryModel
+import java.text.NumberFormat
+import java.util.Locale
 
 fun ProductEntity.Categories.SubCategories.Products.toDomain(): ProductVO {
     return ProductVO(
@@ -33,4 +39,20 @@ fun SearchHistoryVO.toSearchHistoryEntity(): SearchHistoryEntity {
         search = search,
         timeStamp = timeStamp
     )
+}
+
+fun CommonProductEntity.toProductsVO(): ProductsVO {
+    return ProductsVO(
+        productId = productId,
+        productName = productName,
+        brandName = brandName,
+        imageUrl = imageUrl,
+        originalPrice = originalPrice,
+        discountPercent = discountPercent,
+        discountPrice = discountPrice,
+        tags = tags,
+        reviewRating = reviewRating,
+        reviewCount = reviewCount,
+        categoryIds = categoryIds,
+    )
 }

feature/search/src/main/java/com/chan/search/data/repository/SearchRepositoryImpl.kt

@@ -1,24 +1,34 @@
 package com.chan.search.data.repository
 
+import com.chan.database.dao.CategoryDao
 import com.chan.database.dao.ProductDao
+import com.chan.database.dao.ProductsDao
 import com.chan.database.dao.SearchHistoryDao
 import com.chan.domain.ProductVO
+import com.chan.domain.ProductsVO
+import com.chan.search.data.mappers.toCategoryVO
 import com.chan.search.data.mappers.toDomain
+import com.chan.search.data.mappers.toProductsVO
 import com.chan.search.data.mappers.toSearchHistoryEntity
+import com.chan.search.domain.model.FilterCategoryListVO
 import com.chan.search.domain.model.SearchHistoryVO
 import com.chan.search.domain.repository.SearchRepository
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import javax.inject.Inject
 
 class SearchRepositoryImpl @Inject constructor(
-    private val productDao: ProductDao,
-    private val searchHistoryDao: SearchHistoryDao
+    private val searchHistoryDao: SearchHistoryDao,
+    private val productsDao: ProductsDao,
+    private val categoryDao: CategoryDao
 ) : SearchRepository {
-    override suspend fun searchProductName(search: String): List<ProductVO> {
-        return productDao.searchProductsByName(search).map { it.toDomain() }
+    override suspend fun searchProductName(search: String): List<ProductsVO> {
+        return productsDao.searchProductsByName(search).map { it.toProductsVO() }
     }
 
+    override suspend fun getSearchResultProducts(search: String): List<ProductsVO> {
+        return productsDao.searchProductsByName(search).map { it.toProductsVO() }
+    }
 
     override fun getRecentSearches(): Flow<List<SearchHistoryVO>> {
         return searchHistoryDao.getRecentSearches()
@@ -41,7 +51,32 @@ class SearchRepositoryImpl @Inject constructor(
         return searchHistoryDao.clearAll()
     }
 
-    override suspend fun getSearchResultProducts(search: String): List<ProductVO> {
-        return productDao.searchProductsByName(search).map { it.toDomain() }
+    override suspend fun getFilterCategories(): List<FilterCategoryListVO> {
+        val allCategories = categoryDao.getAllCategories()
+
+        val childrenMap = allCategories
+            .filter { it.parentCategoryId != null }
+            .groupBy { it.parentCategoryId!! }
+
+        return allCategories
+            .filter { it.parentCategoryId == null }
+            .map { parentEntity ->
+                val childrenEntities = childrenMap[parentEntity.id] ?: emptyList()
+
+                FilterCategoryListVO(
+                    parent = parentEntity.toCategoryVO(),
+                    children = childrenEntities.map { it.toCategoryVO() }
+                )
+            }
+    }
+
+    //DB 쿼리로 필터링 제한
+    override suspend fun getFilteredProducts(selectedCategoryId: Set<String>): List<ProductsVO> {
+        val allProducts = productsDao.getAllProducts()
+        return allProducts
+            .filter { product ->
+                product.categoryIds.any { it in selectedCategoryId }
+            }
+            .map { it.toProductsVO() }
     }
 }

feature/search/src/main/java/com/chan/search/domain/model/FilterCategoriesVO.kt

@@ -0,0 +1,12 @@
+package com.chan.search.domain.model
+
+data class FilterCategoriesVO(
+    val categoryId: String,
+    val name: String,
+    val subCategories: List<SubCategoryVO>
+)
+
+data class SubCategoryVO(
+    val subCategoryId: String,
+    val subCategoryName: String,
+)

feature/search/src/main/java/com/chan/search/domain/model/FilterCategoryListVO.kt

@@ -0,0 +1,11 @@
+package com.chan.search.domain.model
+
+data class FilterCategoryListVO(
+    val parent: CategoryVO,
+    val children: List<CategoryVO>
+)
+
+data class CategoryVO(
+    val id: String,
+    val name: String
+)