feature: 봉달목록에 상품 추가 api

build.gradle.kts

@@ -20,34 +20,36 @@ repositories {
 }
 
 dependencies {
+    // kotlin
+    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
+    implementation("org.jetbrains.kotlin:kotlin-reflect")
+
+    // spring data jpa
     implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+
+    // spring boot web
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-webflux")
-    implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
-    implementation("org.jetbrains.kotlin:kotlin-reflect")
+
+    // jwt
     implementation("io.jsonwebtoken:jjwt-api:0.11.5")
     implementation("io.jsonwebtoken:jjwt-impl:0.11.5")
     implementation("io.jsonwebtoken:jjwt-jackson:0.11.5")
-    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
-
-    // kotlin jdsl
-    implementation("com.linecorp.kotlin-jdsl:jpql-dsl:3.3.0")
-    implementation("com.linecorp.kotlin-jdsl:jpql-render:3.3.0")
-
-    implementation("org.springframework.boot:spring-boot-starter-cache")
 
-    implementation("io.jsonwebtoken:jjwt-api:0.11.5")
+    // annotation processor
+    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
 
     // kotlin jdsl
     implementation("com.linecorp.kotlin-jdsl:jpql-dsl:3.3.0")
     implementation("com.linecorp.kotlin-jdsl:jpql-render:3.3.0")
 
+    // spring boot cache
     implementation("org.springframework.boot:spring-boot-starter-cache")
-
+    
     runtimeOnly("com.mysql:mysql-connector-j")
     runtimeOnly("com.h2database:h2")
 
-    annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
+    testImplementation("io.mockk:mockk:1.13.9")
     testImplementation("org.springframework.boot:spring-boot-starter-test")
     testImplementation("io.kotest:kotest-runner-junit5:5.4.2")
     testImplementation("io.kotest:kotest-assertions-core:5.4.2")

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

@@ -0,0 +1,29 @@
+package com.petqua.application.cart
+
+import com.petqua.application.cart.dto.SaveCartProductCommand
+import com.petqua.common.domain.existByIdOrThrow
+import com.petqua.domain.cart.CartProductRepository
+import com.petqua.domain.member.MemberRepository
+import com.petqua.domain.product.ProductRepository
+import com.petqua.exception.member.MemberException
+import com.petqua.exception.member.MemberExceptionType.NOT_FOUND_MEMBER
+import com.petqua.exception.product.ProductException
+import com.petqua.exception.product.ProductExceptionType.NOT_FOUND_PRODUCT
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Transactional
+@Service
+class CartProductService(
+    private val cartProductRepository: CartProductRepository,
+    private val productRepository: ProductRepository,
+    private val memberRepository: MemberRepository,
+) {
+
+    fun save(command: SaveCartProductCommand): Long {
+        memberRepository.existByIdOrThrow(command.memberId, MemberException(NOT_FOUND_MEMBER))
+        productRepository.existByIdOrThrow(command.productId, ProductException(NOT_FOUND_PRODUCT))
+        val savedCartProduct = cartProductRepository.save(command.toCartProduct())
+        return savedCartProduct.id
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.petqua.application.cart.dto
+
+import com.petqua.domain.cart.CartProduct
+import com.petqua.domain.cart.CartProductQuantity
+import com.petqua.domain.cart.DeliveryMethod
+
+data class SaveCartProductCommand(
+    val memberId: Long,
+    val productId: Long,
+    val quantity: Int,
+    val isMale: Boolean,
+    val deliveryMethod: DeliveryMethod,
+) {
+    fun toCartProduct(): CartProduct {
+        return CartProduct(
+            memberId = memberId,
+            productId = productId,
+            quantity = CartProductQuantity(quantity),
+            isMale = isMale,
+            deliveryMethod = deliveryMethod,
+        )
+    }
+}

src/main/kotlin/com/petqua/common/domain/Repository.kt

@@ -6,3 +6,9 @@ import org.springframework.data.repository.findByIdOrNull
 inline fun <reified T, ID> CrudRepository<T, ID>.findByIdOrThrow(
     id: ID, e: Exception = IllegalArgumentException("${T::class.java.name} entity 를 찾을 수 없습니다. id=$id")
 ): T = findByIdOrNull(id) ?: throw e
+
+
+inline fun <reified T, ID> CrudRepository<T, ID>.existByIdOrThrow(
+    id: ID,
+    e: Exception = IllegalArgumentException("${T::class.java.name} entity 를 찾을 수 없습니다. id=$id")
+): Unit = if (!existsById(id!!)) throw e else Unit

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

@@ -0,0 +1,5 @@
+package com.petqua.common.util
+
+inline fun throwExceptionWhen(condition: Boolean, exceptionSupplier: () -> RuntimeException) {
+    if (condition) throw exceptionSupplier()
+}

src/main/kotlin/com/petqua/domain/auth/Accessor.kt → src/main/kotlin/com/petqua/domain/auth/LoginMember.kt

@@ -2,14 +2,14 @@ package com.petqua.domain.auth
 
 import com.petqua.domain.auth.token.AccessTokenClaims
 
-class Accessor(
+class LoginMember(
     val memberId: Long,
     val authority: Authority,
 ) {
 
     companion object {
-        fun from(accessTokenClaims: AccessTokenClaims): Accessor {
-            return Accessor(
+        fun from(accessTokenClaims: AccessTokenClaims): LoginMember {
+            return LoginMember(
                 memberId = accessTokenClaims.memberId,
                 authority = accessTokenClaims.authority
             )

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

@@ -0,0 +1,33 @@
+package com.petqua.domain.cart
+
+import com.petqua.common.domain.BaseEntity
+import jakarta.persistence.Column
+import jakarta.persistence.Embedded
+import jakarta.persistence.Entity
+import jakarta.persistence.EnumType
+import jakarta.persistence.Enumerated
+import jakarta.persistence.GeneratedValue
+import jakarta.persistence.GenerationType
+import jakarta.persistence.Id
+
+@Entity
+class CartProduct(
+    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
+    val id: Long = 0L,
+
+    @Column(nullable = false)
+    val memberId: Long,
+
+    @Column(nullable = false)
+    val productId: Long,
+
+    @Embedded
+    val quantity: CartProductQuantity,
+
+    @Column(nullable = false)
+    val isMale: Boolean,
+
+    @Enumerated(value = EnumType.STRING)
+    @Column(nullable = false)
+    val deliveryMethod: DeliveryMethod,
+) : BaseEntity()

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

@@ -0,0 +1,23 @@
+package com.petqua.domain.cart
+
+import com.petqua.common.util.throwExceptionWhen
+import com.petqua.exception.cart.CartProductException
+import com.petqua.exception.cart.CartProductExceptionType.PRODUCT_QUANTITY_OVER_MAXIMUM
+import com.petqua.exception.cart.CartProductExceptionType.PRODUCT_QUANTITY_UNDER_MINIMUM
+import jakarta.persistence.Column
+import jakarta.persistence.Embeddable
+
+private const val MIN_QUANTITY = 1
+private const val MAX_QUANTITY = 99
+
+@Embeddable
+class CartProductQuantity(
+    @Column(nullable = false)
+    val quantity: Int = 1,
+) {
+
+    init {
+        throwExceptionWhen(quantity < MIN_QUANTITY) { CartProductException(PRODUCT_QUANTITY_UNDER_MINIMUM) }
+        throwExceptionWhen(quantity > MAX_QUANTITY) { CartProductException(PRODUCT_QUANTITY_OVER_MAXIMUM) }
+    }
+}

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

@@ -0,0 +1,5 @@
+package com.petqua.domain.cart
+
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface CartProductRepository : JpaRepository<CartProduct, Long>

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

@@ -0,0 +1,22 @@
+package com.petqua.domain.cart
+
+import com.petqua.exception.cart.CartProductException
+import com.petqua.exception.cart.CartProductExceptionType.INVALID_DELIVERY_METHOD
+import java.util.Locale.ENGLISH
+
+enum class DeliveryMethod(
+    val description: String,
+) {
+
+    COMMON("일반 운송"),
+    SAFETY("안전 운송"),
+    PICK_UP("직접 방문"),
+    ;
+
+    companion object {
+        fun from(name: String): DeliveryMethod {
+            return enumValues<DeliveryMethod>().find { it.name == name.uppercase(ENGLISH) }
+                ?: throw CartProductException(INVALID_DELIVERY_METHOD)
+        }
+    }
+}

src/main/kotlin/com/petqua/exception/cart/CartProductException.kt

@@ -0,0 +1,13 @@
+package com.petqua.exception.cart
+
+import com.petqua.common.exception.BaseException
+import com.petqua.common.exception.BaseExceptionType
+
+class CartProductException(
+    private val exceptionType: CartProductExceptionType,
+) : BaseException() {
+
+    override fun exceptionType(): BaseExceptionType {
+        return exceptionType
+    }
+}

src/main/kotlin/com/petqua/exception/cart/CartProductExceptionType.kt

@@ -0,0 +1,24 @@
+package com.petqua.exception.cart
+
+import com.petqua.common.exception.BaseExceptionType
+import org.springframework.http.HttpStatus
+import org.springframework.http.HttpStatus.BAD_REQUEST
+
+enum class CartProductExceptionType(
+    private val httpStatus: HttpStatus,
+    private val errorMessage: String,
+) : BaseExceptionType {
+
+    INVALID_DELIVERY_METHOD(httpStatus = BAD_REQUEST, errorMessage = "유효하지 않는 배송 방법입니다."),
+    PRODUCT_QUANTITY_UNDER_MINIMUM(httpStatus = BAD_REQUEST, errorMessage = "최소 1개 이상의 상품을 담을 수 있습니다."),
+    PRODUCT_QUANTITY_OVER_MAXIMUM(httpStatus = BAD_REQUEST, errorMessage = "최대 99개까지 구매할 수 있습니다."),
+    ;
+
+    override fun httpStatus(): HttpStatus {
+        return httpStatus
+    }
+
+    override fun errorMessage(): String {
+        return errorMessage
+    }
+}

src/main/kotlin/com/petqua/exception/member/MemberException.kt

@@ -0,0 +1,13 @@
+package com.petqua.exception.member
+
+import com.petqua.common.exception.BaseException
+import com.petqua.common.exception.BaseExceptionType
+
+class MemberException(
+    private val exceptionType: MemberExceptionType,
+) : BaseException() {
+
+    override fun exceptionType(): BaseExceptionType {
+        return exceptionType
+    }
+}

src/main/kotlin/com/petqua/exception/member/MemberExceptionType.kt

@@ -0,0 +1,22 @@
+package com.petqua.exception.member
+
+import com.petqua.common.exception.BaseExceptionType
+import org.springframework.http.HttpStatus
+import org.springframework.http.HttpStatus.NOT_FOUND
+
+enum class MemberExceptionType(
+    private val httpStatus: HttpStatus,
+    private val errorMessage: String,
+) : BaseExceptionType {
+
+    NOT_FOUND_MEMBER(NOT_FOUND, "존재하지 않는 회원입니다."),
+    ;
+
+    override fun httpStatus(): HttpStatus {
+        return httpStatus
+    }
+
+    override fun errorMessage(): String {
+        return errorMessage
+    }
+}

src/main/kotlin/com/petqua/presentation/auth/LoginArgumentResolver.kt

@@ -2,8 +2,8 @@ package com.petqua.presentation.auth
 
 import com.petqua.common.exception.auth.AuthException
 import com.petqua.common.exception.auth.AuthExceptionType
-import com.petqua.domain.auth.Accessor
 import com.petqua.domain.auth.Auth
+import com.petqua.domain.auth.LoginMember
 import com.petqua.domain.auth.token.AuthTokenProvider
 import com.petqua.domain.auth.token.RefreshTokenRepository
 import jakarta.servlet.http.HttpServletRequest
@@ -25,29 +25,29 @@ class LoginArgumentResolver(
 
     override fun supportsParameter(parameter: MethodParameter): Boolean {
         return parameter.hasParameterAnnotation(Auth::class.java)
-                && parameter.getParameterType() == Accessor::class.java
+                && parameter.getParameterType() == LoginMember::class.java
     }
 
     override fun resolveArgument(
         parameter: MethodParameter,
         mavContainer: ModelAndViewContainer?,
         webRequest: NativeWebRequest,
         binderFactory: WebDataBinderFactory?
-    ): Accessor {
+    ): LoginMember {
         val request = webRequest.getNativeRequest(HttpServletRequest::class.java)
             ?: throw AuthException(AuthExceptionType.INVALID_REQUEST)
-        val refreshToken = request.cookies?.find {it.name == REFRESH_TOKEN_COOKIE}?.value
+        val refreshToken = request.cookies?.find { it.name == REFRESH_TOKEN_COOKIE }?.value
         val accessToken = webRequest.getHeader(HttpHeaders.AUTHORIZATION) as String
         val accessTokenClaims = authTokenProvider.getAccessTokenClaims(accessToken)
         if (refreshToken == null) {
-            return Accessor.from(accessTokenClaims)
+            return LoginMember.from(accessTokenClaims)
         }
 
         val savedRefreshToken = refreshTokenRepository.findByMemberId(accessTokenClaims.memberId)
             ?: throw AuthException(AuthExceptionType.INVALID_REFRESH_TOKEN)
         if (savedRefreshToken.token == refreshToken) {
-            return Accessor.from(accessTokenClaims)
+            return LoginMember.from(accessTokenClaims)
         }
         throw AuthException(AuthExceptionType.INVALID_REFRESH_TOKEN)
     }
-}
+}

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

@@ -0,0 +1,34 @@
+package com.petqua.presentation.cart
+
+import com.petqua.application.cart.CartProductService
+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 org.springframework.http.ResponseEntity
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RestController
+import org.springframework.web.servlet.support.ServletUriComponentsBuilder
+
+@RequestMapping("/carts")
+@RestController
+class CartProductController(
+    private val cartProductService: CartProductService,
+) {
+
+    @PostMapping
+    fun save(
+        @Auth loginMember: LoginMember,
+        @RequestBody request: SaveCartProductRequest
+    ): ResponseEntity<ProductDetailResponse> {
+        val command = request.toCommand(loginMember.memberId)
+        val cartProductId = cartProductService.save(command)
+        val location = ServletUriComponentsBuilder.fromCurrentRequest()
+            .path("/items/{id}")
+            .buildAndExpand(cartProductId)
+            .toUri()
+        return ResponseEntity.created(location).build()
+    }
+}