feature: 봉달 목록 조회 api

src/main/kotlin/com/petqua/application/cart/CartProductService.kt

@@ -1,14 +1,17 @@
 package com.petqua.application.cart
 
+import com.petqua.application.cart.dto.CartProductResponse
 import com.petqua.application.cart.dto.DeleteCartProductCommand
 import com.petqua.application.cart.dto.SaveCartProductCommand
 import com.petqua.application.cart.dto.UpdateCartProductOptionCommand
 import com.petqua.common.domain.existByIdOrThrow
 import com.petqua.common.domain.findByIdOrThrow
+import com.petqua.domain.cart.CartProduct
 import com.petqua.domain.cart.CartProductRepository
 import com.petqua.domain.cart.DeliveryMethod
 import com.petqua.domain.member.MemberRepository
 import com.petqua.domain.product.ProductRepository
+import com.petqua.domain.product.dto.ProductResponse
 import com.petqua.exception.cart.CartProductException
 import com.petqua.exception.cart.CartProductExceptionType.DUPLICATED_PRODUCT
 import com.petqua.exception.cart.CartProductExceptionType.NOT_FOUND_CART_PRODUCT
@@ -76,4 +79,21 @@ class CartProductService(
         cartProduct.validateOwner(command.memberId)
         cartProductRepository.delete(cartProduct)
     }
+
+    @Transactional(readOnly = true)
+    fun readAll(memberId: Long): List<CartProductResponse> {
+        memberRepository.existByIdOrThrow(memberId, MemberException(NOT_FOUND_MEMBER))
+        val cartProducts = cartProductRepository.findAllByMemberId(memberId)
+        val products = productByIds(cartProducts)
+        val findAll = productRepository.findAll()
+        return cartProducts.map {
+            products[it.id]?.let { product -> CartProductResponse.of(it, product) }
+                ?: CartProductResponse.fromDeletedProduct(it)
+        }
+    }
+
+    private fun productByIds(cartProducts: List<CartProduct>): Map<Long, ProductResponse> {
+        val productIdsFromCart = cartProducts.map { it.productId }
+        return productRepository.findAllProductResponseByIdIn(productIdsFromCart).associateBy { it.id }
+    }
 }

src/main/kotlin/com/petqua/application/cart/dto/CartProductDtos.kt

@@ -3,6 +3,7 @@ package com.petqua.application.cart.dto
 import com.petqua.domain.cart.CartProduct
 import com.petqua.domain.cart.CartProductQuantity
 import com.petqua.domain.cart.DeliveryMethod
+import com.petqua.domain.product.dto.ProductResponse
 
 data class SaveCartProductCommand(
     val memberId: Long,
@@ -35,3 +36,56 @@ data class DeleteCartProductCommand(
     val memberId: Long,
     val cartProductId: Long,
 )
+
+data class CartProductResponse(
+    val id: Long,
+    val storeName: String,
+    val productId: Long,
+    val productName: String,
+    val productThumbnailUrl: String,
+    val productPrice: Int,
+    val productDiscountRate: Int,
+    val productDiscountPrice: Int,
+    val quantity: Int,
+    val isMale: Boolean,
+    val deliveryMethod: String,
+    val isOnSale: Boolean,
+) {
+
+    companion object {
+        fun of(cartProduct: CartProduct, productResponse: ProductResponse): CartProductResponse {
+            return CartProductResponse(
+                id = cartProduct.id,
+                storeName = productResponse.storeName,
+                productId = productResponse.id,
+                productName = productResponse.name,
+                productThumbnailUrl = productResponse.thumbnailUrl,
+                productPrice = productResponse.price,
+                productDiscountRate = productResponse.discountRate,
+                productDiscountPrice = productResponse.discountPrice,
+                quantity = cartProduct.quantity.value,
+                isMale = cartProduct.isMale,
+                deliveryMethod = cartProduct.deliveryMethod.name,
+                isOnSale = true,
+            )
+        }
+
+
+        fun fromDeletedProduct(cartProduct: CartProduct): CartProductResponse {
+            return CartProductResponse(
+                id = cartProduct.id,
+                storeName = "",
+                productId = cartProduct.productId,
+                productName = "",
+                productThumbnailUrl = "",
+                productPrice = 0,
+                productDiscountRate = 0,
+                productDiscountPrice = 0,
+                quantity = cartProduct.quantity.value,
+                isMale = cartProduct.isMale,
+                deliveryMethod = cartProduct.deliveryMethod.name,
+                isOnSale = false,
+            )
+        }
+    }
+}

src/main/kotlin/com/petqua/common/util/EntityManagerUtils.kt

@@ -29,6 +29,17 @@ inline fun <reified T> EntityManager.createQuery(
         .resultList
 }
 
+inline fun <reified T> EntityManager.createQuery(
+    query: SelectQuery<*>,
+    context: JpqlRenderContext,
+    renderer: JpqlRenderer,
+): List<T> {
+    val rendered = renderer.render(query, context)
+    return this.createQuery(rendered.query, T::class.java)
+        .apply { rendered.params.forEach { (name, value) -> setParameter(name, value) } }
+        .resultList
+}
+
 inline fun <reified T> EntityManager.createCountQuery(
     query: SelectQuery<*>,
     context: JpqlRenderContext,

src/main/kotlin/com/petqua/domain/cart/CartProductRepository.kt

@@ -11,5 +11,5 @@ interface CartProductRepository : JpaRepository<CartProduct, Long> {
         deliveryMethod: DeliveryMethod
     ): CartProduct?
 
-    fun findAllByIdIn(ids: List<Long>): List<CartProduct>
+    fun findAllByMemberId(id: Long): List<CartProduct>
 }

src/main/kotlin/com/petqua/domain/product/ProductCustomRepository.kt

@@ -9,4 +9,6 @@ interface ProductCustomRepository {
     fun findAllByCondition(condition: ProductReadCondition, paging: ProductPaging): List<ProductResponse>
 
     fun countByCondition(condition: ProductReadCondition): Int
+
+    fun findAllProductResponseByIdIn(ids: List<Long>): List<ProductResponse>
 }

src/main/kotlin/com/petqua/domain/product/ProductCustomRepositoryImpl.kt

@@ -96,4 +96,26 @@ class ProductCustomRepositoryImpl(
             jpqlRenderer
         )
     }
+
+    override fun findAllProductResponseByIdIn(ids: List<Long>): List<ProductResponse> {
+        val query = jpql {
+            selectNew<ProductResponse>(
+                entity(Product::class),
+                path(Store::name)
+            ).from(
+                entity(Product::class),
+                join(Store::class).on(path(Product::storeId).eq(path(Store::id))),
+            ).where(
+                predicateByIds(ids)
+            )
+        }
+
+        return entityManager.createQuery(
+            query,
+            jpqlRenderContext,
+            jpqlRenderer
+        )
+    }
+
+    private fun Jpql.predicateByIds(ids: List<Long>) = if (ids.isEmpty()) null else path(Product::id).`in`(ids)
 }

src/main/kotlin/com/petqua/presentation/cart/CartProductController.kt

@@ -2,13 +2,15 @@ package com.petqua.presentation.cart
 
 import com.petqua.application.cart.CartProductService
 import com.petqua.application.cart.dto.DeleteCartProductCommand
+import com.petqua.application.cart.dto.CartProductResponse
 import com.petqua.application.product.dto.ProductDetailResponse
 import com.petqua.domain.auth.Auth
 import com.petqua.domain.auth.LoginMember
 import com.petqua.presentation.cart.dto.SaveCartProductRequest
 import com.petqua.presentation.cart.dto.UpdateCartProductOptionRequest
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.DeleteMapping
+import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PatchMapping
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.PostMapping
@@ -60,4 +62,12 @@ class CartProductController(
         cartProductService.delete(command)
         return ResponseEntity.noContent().build()
     }
+
+    @GetMapping
+    fun readAll(
+        @Auth loginMember: LoginMember,
+    ): ResponseEntity<List<CartProductResponse>> {
+        val responses = cartProductService.readAll(loginMember.memberId)
+        return ResponseEntity.ok(responses)
+    }
 }

src/test/kotlin/com/petqua/application/cart/CartProductServiceTest.kt

@@ -10,6 +10,7 @@ import com.petqua.domain.cart.DeliveryMethod.COMMON
 import com.petqua.domain.cart.DeliveryMethod.SAFETY
 import com.petqua.domain.member.MemberRepository
 import com.petqua.domain.product.ProductRepository
+import com.petqua.domain.store.StoreRepository
 import com.petqua.exception.cart.CartProductException
 import com.petqua.exception.cart.CartProductExceptionType.DUPLICATED_PRODUCT
 import com.petqua.exception.cart.CartProductExceptionType.FORBIDDEN_CART_PRODUCT
@@ -22,6 +23,7 @@ import com.petqua.test.DataCleaner
 import com.petqua.test.fixture.cartProduct
 import com.petqua.test.fixture.member
 import com.petqua.test.fixture.product
+import com.petqua.test.fixture.store
 import io.kotest.assertions.assertSoftly
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.BehaviorSpec
@@ -35,6 +37,7 @@ class CartProductServiceTest(
     private val cartProductRepository: CartProductRepository,
     private val productRepository: ProductRepository,
     private val memberRepository: MemberRepository,
+    private val storeRepository: StoreRepository,
     private val dataCleaner: DataCleaner,
 ) : BehaviorSpec({
 
@@ -173,16 +176,16 @@ class CartProductServiceTest(
                 cartProduct(
                     memberId = memberId,
                     productId = productId,
-                    isMale = true,
-                    deliveryMethod = COMMON
+                    isMale = false,
+                    deliveryMethod = SAFETY
                 )
             )
             val command = UpdateCartProductOptionCommand(
                 cartProductId = cartProduct.id,
                 memberId = memberId,
                 quantity = CartProductQuantity(3),
-                isMale = true,
-                deliveryMethod = COMMON,
+                isMale = false,
+                deliveryMethod = SAFETY,
             )
             Then("예외가 발생 한다") {
                 shouldThrow<CartProductException> {
@@ -251,6 +254,58 @@ class CartProductServiceTest(
         }
     }
 
+    Given("봉달 상품 조회시") {
+        val store = storeRepository.save(store(name = "store"))
+        val productAId = productRepository.save(product(storeId = store.id)).id
+        val productBId = productRepository.save(product(storeId = store.id)).id
+        val productCId = productRepository.save(product(storeId = store.id)).id
+        val memberId = memberRepository.save(member()).id
+        cartProductRepository.saveAll(
+            listOf(
+                cartProduct(memberId = memberId, productId = productAId),
+                cartProduct(memberId = memberId, productId = productBId),
+                cartProduct(memberId = memberId, productId = productCId),
+            )
+        )
+
+        When("봉달 상품이 있는 회원이 조회 하는 경우") {
+            val result = cartProductService.readAll(memberId)
+
+            Then("봉달 상품 리스트를 반환 한다") {
+                result.size shouldBe 3
+            }
+        }
+
+        When("봉달 상품이 없는 회원이 조회 하는 경우") {
+            val newMemberId = memberRepository.save(member()).id
+            val results = cartProductService.readAll(newMemberId)
+
+            Then("빈 리스트를 반환 한다") {
+                results.size shouldBe 0
+            }
+        }
+
+        When("봉달에 담아둔 상품이 삭제된 경우") {
+            productRepository.deleteById(productAId)
+            val results = cartProductService.readAll(memberId)
+
+            Then("빈 리스트를 반환 한다") {
+                assertSoftly(results) {
+                    size shouldBe 3
+                    find { it.productId == productAId }!!.isOnSale shouldBe false
+                }
+            }
+        }
+
+        When("존재 하지 않는 회원이 조회 하는 경우") {
+            Then("예외가 발생 한다") {
+                shouldThrow<MemberException> {
+                    cartProductService.readAll(Long.MIN_VALUE)
+                }.exceptionType() shouldBe NOT_FOUND_MEMBER
+            }
+        }
+    }
+
     afterContainer {
         dataCleaner.clean()
     }

src/test/kotlin/com/petqua/domain/product/ProductCustomRepositoryImplTest.kt

@@ -177,6 +177,22 @@ class ProductCustomRepositoryImplTest(
         }
     }
 
+    Given("다중 id로 ProductResponse를 조회 할 때") {
+        val product1 = productRepository.save(product(name = "상품1", storeId = store.id))
+        val product2 = productRepository.save(product(name = "상품2", storeId = store.id))
+
+        When("id 목록을 입력하면") {
+            val products = productRepository.findAllProductResponseByIdIn(listOf(product1.id, product2.id))
+
+            Then("해당 id의 ProductResponse를 반환한다") {
+                products shouldContainExactly listOf(
+                    ProductResponse(product1, store.name),
+                    ProductResponse(product2, store.name),
+                )
+            }
+        }
+    }
+
     afterContainer {
         dataCleaner.clean()
     }

src/test/kotlin/com/petqua/presentation/cart/CartProductControllerSteps.kt

@@ -77,3 +77,18 @@ fun requestDeleteCartProduct(
         response()
     }
 }
+
+fun requestReadAllCartProducts(
+    accessToken: String
+): Response {
+    return Given {
+        log().all()
+            .header(HttpHeaders.AUTHORIZATION, accessToken)
+    } When {
+        get("/carts")
+    } Then {
+        log().all()
+    } Extract {
+        response()
+    }
+}