🚀 4단계 - 장바구니(수량)

README.md

@@ -22,4 +22,13 @@
   - [x] 담긴 상품의 수량을 조절할 수 있어야 한다.
   - [x] 수량을 1보다 작게 하면 장바구니에서 상품이 제거된다.
   - [x] 담긴 상품 가격의 총합이 주문하기 버튼에 표시된다.
-- [ ] 장바구니 화면에 대한 테스트 코드를 작성한다.
+- [x] 장바구니 화면에 대한 테스트 코드를 작성한다.
+
+🚀 4단계 - 장바구니(수량)
+- [x] 버그 수정 : 장바구니에 아이템이 담기지 않는 문제 수정하기
+- [x] 이전 피드백 반영 : CartItem의 totalPrice get으로 매번 값을 계산하지 않고, state로 저장하도록 수정
+- [x 상품 목록에서 장바구니에 담을/담긴 상품의 수량을 조절할 수 있다
+  - [x] 장바구니에 담기지 않은 아이템에 대해 장바구니에 담을 수 있는 + 버튼을 추가한다.
+  - [x] 장바구니에 담긴 아이템은 수량 조절 UI를 보여준다.
+  - [ ] (optional) + 버튼에서 수량 조절 UI로 변경할 때 B마트처럼 애니메이션을 이용한다.
+- [x] 상품 목록 화면에서 장바구니에 담긴 수량 만큼 우측 상단에 수량을 뱃지로 표시한다.

app/src/androidTest/java/nextstep/shoppingcart/BasketScreenTest.kt

@@ -49,15 +49,18 @@ internal class BasketScreenTest {
                     onRemoveCartItemClick = { removeItem ->
                         state = state.copy(
                             cartItems = state.cartItems.filterNot { item ->
-                                item == removeItem
+                                item.product == removeItem
                             }
                         )
                     },
                     onIncreaseQuantityClick = { increaseItem ->
                         state = state.copy(
                             cartItems = state.cartItems.map { item ->
-                                if (item == increaseItem) {
-                                    item.copy(count = item.count + 1)
+                                if (item.product == increaseItem) {
+                                    item.copy(
+                                        product = item.product.copy(cartQuantity = item.quantity + 1),
+                                        quantity = item.quantity + 1,
+                                    )
                                 } else {
                                     item
                                 }
@@ -66,17 +69,17 @@ internal class BasketScreenTest {
                     },
                     onDecreaseQuantityClick = { decreaseItem ->
                         val newCartItems = state.cartItems.let { items ->
-                            items.find { it.product == decreaseItem.product }?.let { item ->
-                                if (item.count > 1) {
+                            items.find { it.product == decreaseItem }?.let { item ->
+                                if (item.quantity > 1) {
                                     items.map { current ->
-                                        if (current.product == decreaseItem.product) {
-                                            current.copy(count = current.count - 1)
+                                        if (current.product == decreaseItem) {
+                                            current.copy(quantity = current.quantity - 1)
                                         } else {
                                             current
                                         }
                                     }
                                 } else {
-                                    items.filterNot { it.product == decreaseItem.product }
+                                    items.filterNot { it.product == decreaseItem }
                                 }
                             } ?: items
                         }
@@ -158,8 +161,9 @@ internal class BasketScreenTest {
                     imageUrl = "",
                     name = "Item $it",
                     price = 100,
+                    cartQuantity = 1,
                 ),
-                count = 1,
+                quantity = 1,
             )
         }
     }

app/src/main/java/nextstep/shoppingcart/data/datasource/CartLocalDataSource.kt

@@ -3,59 +3,22 @@ package nextstep.shoppingcart.data.datasource
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
 import nextstep.shoppingcart.data.model.CartItemEntity
-import nextstep.shoppingcart.data.model.ProductEntity
 
-/**
- * Room과 같은 역할을 한다고 가정하고 작성했습니다.
- */
 class CartLocalDataSource {
 
-    // MutableList로 구현하면 Flow<List<CartItemEntity>>로 반환할 방법이 없어서 MutableStateFlow로 변경했습니다.
-    private val _itemsFlow = MutableStateFlow<List<CartItemEntity>>(emptyList())
-    val itemsFlow: Flow<List<CartItemEntity>> = _itemsFlow.asStateFlow()
+    private val _itemsFlow = MutableStateFlow<LinkedHashMap<String, CartItemEntity>>(linkedMapOf())
+    val items: Flow<LinkedHashMap<String, CartItemEntity>> = _itemsFlow.asStateFlow()
 
-    fun addOne(product: ProductEntity) {
-        _itemsFlow.update { items ->
-            val isExistingItem = items.any { it.product == product }
-            if (isExistingItem) {
-                items + CartItemEntity(product, 1)
-            } else {
-                items.map { item ->
-                    if (item.product == product) {
-                        item.copy(count = item.count + 1)
-                    } else {
-                        item
-                    }
-                }
-            }
+    fun update(itemEntity: CartItemEntity) {
+        val currentMap = _itemsFlow.value.toMutableMap()
+        val productId = itemEntity.product.id
+        if (itemEntity.quantity < 1) {
+            currentMap.remove(productId)
+        } else {
+            currentMap[productId] = itemEntity
         }
 
-    }
-
-    fun removeOne(product: ProductEntity) {
-        _itemsFlow.update { items ->
-            items.find { it.product == product }?.let { item ->
-                if (item.count > 1) {
-                    items.map { current ->
-                        if (current.product == product) {
-                            current.copy(count = current.count - 1)
-                        } else {
-                            current
-                        }
-                    }
-                } else {
-                    items.filterNot { it.product == product }
-                }
-            } ?: items
-        }
-
-    }
-
-    fun removeAll(product: ProductEntity) {
-        _itemsFlow.update { items ->
-            items.filterNot { it.product == product }
-        }
+        _itemsFlow.value = LinkedHashMap(currentMap)
     }
 }

app/src/main/java/nextstep/shoppingcart/data/datasource/ProductLocalDataSource.kt

@@ -0,0 +1,19 @@
+package nextstep.shoppingcart.data.datasource
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import nextstep.shoppingcart.data.model.ProductEntity
+
+/**
+ * Room과 같은 역할을 한다고 가정하고 작성했습니다.
+ */
+class ProductLocalDataSource {
+
+    private val _itemsFlow = MutableStateFlow<List<ProductEntity>>(emptyList())
+    val itemsFlow: Flow<List<ProductEntity>> = _itemsFlow.asStateFlow()
+
+    fun replaceAll(items: List<ProductEntity>) {
+        _itemsFlow.value = items
+    }
+}

app/src/main/java/nextstep/shoppingcart/data/datasource/ProductRemoteDataSource.kt

@@ -1,137 +1,137 @@
 package nextstep.shoppingcart.data.datasource
 
 import kotlinx.coroutines.delay
-import nextstep.shoppingcart.data.model.ProductEntity
+import nextstep.shoppingcart.data.model.ProductResponse
 import java.util.UUID
 import kotlin.random.Random
 
 class ProductRemoteDataSource {
 
     private val random = Random(System.currentTimeMillis())
 
-    suspend fun fetch(): List<ProductEntity> {
+    suspend fun fetch(): List<ProductResponse> {
         delay(random.nextLong(300L, 1000L))
 
         return dummyProducts
     }
 
     companion object {
         internal val dummyProducts = listOf(
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/200/300",
                 name = "치즈버거",
                 price = 5500
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/250/350",
                 name = "페퍼로니 피자",
                 price = 13900
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/180/280",
                 name = "초콜릿 케이크",
                 price = 8900
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/220/320",
                 name = "아이스 아메리카노",
                 price = 4100
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/240/360",
                 name = "후라이드 치킨",
                 price = 16900
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/190/290",
                 name = "딸기 타르트",
                 price = 7500
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/210/310",
                 name = "크로와상",
                 price = 3200
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/230/330",
                 name = "연어 덮밥",
                 price = 13500
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/200/250",
                 name = "스테이크",
                 price = 28900
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/260/360",
                 name = "마카롱 세트",
                 price = 9600
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/180/300",
                 name = "초밥 모둠",
                 price = 19800
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/240/340",
                 name = "랍스터 요리",
                 price = 49900
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/210/290",
                 name = "모카 라떼",
                 price = 4600
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/220/350",
                 name = "불고기 덮밥",
                 price = 12500
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/250/320",
                 name = "망고 빙수",
                 price = 11000
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/230/300",
                 name = "치즈 케이크",
                 price = 7200
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/200/280",
                 name = "바베큐 폭립",
                 price = 27800
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/260/340",
                 name = "새우 파스타",
                 price = 15800
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/190/310",
                 name = "티라미수",
                 price = 8800
             ),
-            ProductEntity(
+            ProductResponse(
                 id = UUID.randomUUID().toString(),
                 imageUrl = "https://picsum.photos/220/300",
                 name = "팝콘 치킨",

app/src/main/java/nextstep/shoppingcart/data/mapper/ProductMapper.kt

@@ -0,0 +1,13 @@
+package nextstep.shoppingcart.data.mapper
+
+import nextstep.shoppingcart.data.model.ProductEntity
+import nextstep.shoppingcart.data.model.ProductResponse
+
+fun ProductResponse.toEntity(): ProductEntity {
+    return ProductEntity(
+        id = id,
+        imageUrl = imageUrl,
+        name = name,
+        price = price,
+    )
+}

app/src/main/java/nextstep/shoppingcart/data/model/CartItemEntity.kt

@@ -2,5 +2,5 @@ package nextstep.shoppingcart.data.model
 
 data class CartItemEntity(
     val product: ProductEntity,
-    val count: Int,
+    val quantity: Int,
 )

app/src/main/java/nextstep/shoppingcart/data/model/ProductResponse.kt

@@ -0,0 +1,8 @@
+package nextstep.shoppingcart.data.model
+
+data class ProductResponse(
+    val id: String,
+    val imageUrl: String,
+    val name: String,
+    val price: Int,
+)

app/src/main/java/nextstep/shoppingcart/data/repository/CartRepository.kt

@@ -1,33 +1,18 @@
 package nextstep.shoppingcart.data.repository
 
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
 import nextstep.shoppingcart.data.datasource.CartLocalDataSource
 import nextstep.shoppingcart.data.model.CartItemEntity
-import nextstep.shoppingcart.data.model.ProductEntity
 import nextstep.shoppingcart.data.util.SingletonHolder
 
-/**
- * 구현을 간소화하기 위해 interface 대신 구현체 바로 사용
- */
 class CartRepository private constructor(
     private val cartLocalDataSource: CartLocalDataSource,
 ) {
 
-    fun getItems(): Flow<List<CartItemEntity>> = cartLocalDataSource.itemsFlow.map { items ->
-        items
-    }
-
-    fun addOne(product: ProductEntity) {
-        cartLocalDataSource.addOne(product)
-    }
-
-    fun removeOne(product: ProductEntity) {
-        cartLocalDataSource.removeOne(product)
-    }
+    val items: Flow<LinkedHashMap<String, CartItemEntity>> = cartLocalDataSource.items
 
-    fun removeAll(product: ProductEntity) {
-        cartLocalDataSource.removeAll(product)
+    fun update(cartItem: CartItemEntity) {
+        cartLocalDataSource.update(cartItem)
     }
 
     companion object : SingletonHolder<CartRepository>(