[FEAT] 룩 조회(스와이프, 상세) 및 좋아요,싫어요 기능 구현

src/main/kotlin/com/dh/baro/cart/presentation/dto/CartResponse.kt

@@ -21,11 +21,11 @@ data class CartResponse(
         private fun CartItem.toResponse() = CartItemResponse(
             itemId = id,
             productId = product.id,
-            productName = product.name,
-            productThumbnailUrl = product.thumbnailUrl,
-            price = product.price,
+            productName = product.getName(),
+            productThumbnailUrl = product.getThumbnailUrl(),
+            price = product.getPrice(),
             quantity = quantity,
-            subtotal = product.price
+            subtotal = product.getPrice()
                 .multiply(BigDecimal(quantity))
                 .setScale(SCALE_NONE, RoundingMode.HALF_UP)
         )

src/main/kotlin/com/dh/baro/core/ErrorMessage.kt

@@ -14,7 +14,7 @@ enum class ErrorMessage(val message: String) {
     KAKAO_USER_FETCH_FAILED("카카오 사용자 정보 조회 실패: %s"),
 
     // Product
-    PRODUCT_NOT_FOUND("상품을 찾을 수 없습니다: %d"),
+    PRODUCT_NOT_FOUND("상품을 찾을 수 없습니다: %s"),
     INVALID_POPULAR_PRODUCT_CURSOR("cursorLikes와 cursorId는 함께 지정하거나 함께 생략해야 합니다."),
     OUT_OF_STOCK("재고가 모두 소진되었습니다: %d"),
 
@@ -28,6 +28,9 @@ enum class ErrorMessage(val message: String) {
 
     // Order
     ORDER_NOT_FOUND("주문을 찾을 수 없습니다: %d"),
+
+    // Look
+    LOOK_NOT_FOUND("룩을 찾을 수 없습니다: %d"),
     ;
 
     fun format(vararg args: Any): String =

src/main/kotlin/com/dh/baro/core/config/WebConfig.kt

@@ -17,16 +17,16 @@ internal class WebConfig(
 
     override fun addCorsMappings(registry: CorsRegistry) {
         registry.addMapping("/**")
-            .allowedOrigins("*")
-            .allowedHeaders("**")
+            .allowedOriginPatterns("*")
             .allowedMethods(*ALLOWED_METHOD_NAMES)
+            .allowedHeaders("*")
+            .allowCredentials(true)
             .maxAge(3600)
     }
 
     companion object {
         private val ALLOWED_METHOD_NAMES = arrayOf(
-            "GET", "HEAD", "POST", "PUT", "DELETE", "TRACE",
-            "OPTIONS", "PATCH"
+            "GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS",
         )
     }
 }

src/main/kotlin/com/dh/baro/identity/domain/service/UserService.kt

@@ -17,6 +17,12 @@ class UserService(
     private val socialAccountRepository: SocialAccountRepository,
 ) {
 
+    fun checkUserExists(userId: Long) {
+        require(userRepository.existsById(userId)) {
+            ErrorMessage.USER_NOT_FOUND.format(userId)
+        }
+    }
+
     fun getUserById(userId: Long): User =
         userRepository.findByIdOrNull(userId)
             ?: throw IllegalArgumentException(ErrorMessage.USER_NOT_FOUND.format(userId))

src/main/kotlin/com/dh/baro/look/application/LookCreateCommand.kt

@@ -0,0 +1,10 @@
+package com.dh.baro.look.application
+
+data class LookCreateCommand(
+    val creatorId: Long,
+    val title: String,
+    val description: String?,
+    val thumbnailUrl: String,
+    val imageUrls: List<String>,
+    val productIds: List<Long>,
+)

src/main/kotlin/com/dh/baro/look/application/LookFacade.kt

@@ -0,0 +1,41 @@
+package com.dh.baro.look.application
+
+import com.dh.baro.identity.domain.service.UserService
+import com.dh.baro.look.domain.*
+import com.dh.baro.look.domain.service.LookService
+import com.dh.baro.look.presentation.dto.LookDetailResponse
+import com.dh.baro.product.domain.service.ProductQueryService
+import org.springframework.data.domain.Slice
+import org.springframework.stereotype.Service
+
+@Service
+class LookFacade(
+    private val userService: UserService,
+    private val productQueryService: ProductQueryService,
+    private val lookService: LookService,
+) {
+
+    fun createLook(cmd: LookCreateCommand): Look {
+        userService.checkUserExists(cmd.creatorId)
+        productQueryService.checkProductsExists(cmd.productIds)
+        return lookService.createLook(cmd)
+    }
+
+    fun getSwipeLooks(userId: Long, cursorId: Long?, size: Int): Slice<Look> =
+        lookService.getSwipeLooks(userId, cursorId, size)
+
+    fun getLookDetail(lookId: Long): LookDetailResponse {
+        val look = lookService.getLookDetail(lookId)
+        val orderedProducts = look.getOrderedProductViews()
+
+        val productIds = orderedProducts.map { it.productId }
+        val products = productQueryService.getAllByIds(productIds)
+
+        return LookDetailResponse.of(
+            look = look,
+            images = look.getOrderedImageViews(),
+            lookProducts = orderedProducts,
+            products = products,
+        )
+    }
+}

src/main/kotlin/com/dh/baro/look/application/LookReactionFacade.kt

@@ -0,0 +1,25 @@
+package com.dh.baro.look.application
+
+import com.dh.baro.identity.domain.service.UserService
+import com.dh.baro.look.domain.ReactionType
+import com.dh.baro.look.domain.service.LookReactionService
+import org.springframework.stereotype.Service
+
+@Service
+class LookReactionFacade(
+    private val userService: UserService,
+    private val lookReactionService: LookReactionService,
+) {
+
+    fun recordReaction(userId: Long, lookId: Long, reactionType: ReactionType) {
+        userService.checkUserExists(userId)
+        lookReactionService.createReactionIfAbsent(
+            userId = userId,
+            lookId = lookId,
+            reactionType = reactionType,
+        )
+    }
+
+    fun cancelReaction(userId: Long, lookId: Long) =
+        lookReactionService.deleteReaction(userId, lookId)
+}

src/main/kotlin/com/dh/baro/look/domain/Look.kt

@@ -1,8 +1,9 @@
 package com.dh.baro.look.domain
 
 import com.dh.baro.core.AbstractTime
-import com.dh.baro.identity.domain.User
-import com.dh.baro.product.domain.Product
+import com.dh.baro.core.IdGenerator
+import com.dh.baro.look.domain.vo.LookImageView
+import com.dh.baro.look.domain.vo.LookProductView
 import jakarta.persistence.*
 
 @Entity
@@ -12,27 +13,110 @@ class Look(
     @Column(name = "id")
     val id: Long,
 
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "creator_id")
-    val creator: User? = null,
+    @Column(name = "creator_id", nullable = false)
+    val creatorId: Long,
 
     @Column(name = "title", nullable = false)
-    var title: String,
+    private var title: String,
 
     @Lob @Column(name = "description")
-    var description: String? = null,
+    private var description: String? = null,
 
     @Column(name = "likes_count", nullable = false)
-    var likesCount: Int = 0,
+    private var likesCount: Int = 0,
 
-    @OneToMany(mappedBy = "look", cascade = [CascadeType.ALL], orphanRemoval = true)
-    val images: MutableList<LookImage> = mutableListOf(),
+    @Column(name = "thumbnail_url", nullable = false, length = 300)
+    private var thumbnailUrl: String,
 
-    @ManyToMany
-    @JoinTable(
-        name = "look_products",
-        joinColumns = [JoinColumn(name = "look_id")],
-        inverseJoinColumns = [JoinColumn(name = "product_id")]
+    @OneToMany(
+        mappedBy = "look",
+        fetch = FetchType.LAZY,
+        cascade = [CascadeType.ALL],
+        orphanRemoval = true,
     )
-    val products: MutableSet<Product> = mutableSetOf()
-) : AbstractTime()
+    private val images: MutableSet<LookImage> = mutableSetOf(),
+
+    @OneToMany(
+        mappedBy = "look",
+        fetch = FetchType.LAZY,
+        cascade = [CascadeType.ALL],
+        orphanRemoval = true,
+    )
+    private val products: MutableSet<LookProduct> = mutableSetOf(),
+) : AbstractTime() {
+
+    fun getTitle() = title
+
+    fun getDescription() = description
+
+    fun getLikesCount() = likesCount
+
+    fun getThumbnailUrl() = thumbnailUrl
+
+    fun getOrderedImageViews(): List<LookImageView> =
+        images.asSequence()
+            .sortedBy { it.displayOrder }
+            .map { LookImageView(it.imageUrl, it.displayOrder) }
+            .toList()
+
+    fun getOrderedProductViews(): List<LookProductView> =
+        products.asSequence()
+            .sortedBy { it.displayOrder }
+            .map { LookProductView(it.productId, it.displayOrder) }
+            .toList()
+
+    fun addImages(imageUrls: List<String>) {
+        val start = images.size
+        imageUrls.forEachIndexed { idx, url ->
+            addImage(
+                imageUrl = url,
+                displayOrder = start + idx + 1,
+            )
+        }
+    }
+
+    private fun addImage(imageUrl: String, displayOrder: Int) =
+        images.add(
+            LookImage.of(
+                look = this,
+                imageUrl = imageUrl,
+                displayOrder = displayOrder,
+            )
+        )
+
+    fun addProducts(productIds: List<Long>) {
+        val nextOrderStart = products.size
+        productIds
+            .distinct()
+            .filterNot { id ->
+                products.any { it.productId == id }
+            }
+            .forEachIndexed { idx, id ->
+                addProduct(id, nextOrderStart + idx + 1)
+            }
+    }
+
+    private fun addProduct(productId: Long, displayOrder: Int) {
+        products += LookProduct.of(
+            look = this,
+            productId = productId,
+            displayOrder = displayOrder,
+        )
+    }
+
+    companion object {
+        fun newLook(
+            creatorId: Long,
+            title: String,
+            description: String?,
+            thumbnailUrl: String,
+        ): Look =
+            Look(
+                id = IdGenerator.generate(),
+                creatorId = creatorId,
+                title = title,
+                description = description,
+                thumbnailUrl = thumbnailUrl,
+            )
+    }
+}

src/main/kotlin/com/dh/baro/look/domain/LookImage.kt

@@ -1,6 +1,7 @@
 package com.dh.baro.look.domain
 
 import com.dh.baro.core.AbstractTime
+import com.dh.baro.core.IdGenerator
 import jakarta.persistence.*
 
 @Entity
@@ -19,7 +20,19 @@ class LookImage(
 
     @Column(name = "display_order", nullable = false)
     val displayOrder: Int,
+) : AbstractTime() {
 
-    @Column(name = "is_thumbnail", nullable = false)
-    val isThumbnail: Boolean = false
-) : AbstractTime()
+    companion object {
+        fun of(
+            look: Look,
+            imageUrl: String,
+            displayOrder: Int,
+        ): LookImage =
+            LookImage(
+                id = IdGenerator.generate(),
+                look = look,
+                imageUrl = imageUrl,
+                displayOrder = displayOrder,
+            )
+    }
+}

src/main/kotlin/com/dh/baro/look/domain/LookProduct.kt

@@ -0,0 +1,42 @@
+package com.dh.baro.look.domain
+
+import com.dh.baro.core.IdGenerator
+import jakarta.persistence.*
+
+@Entity
+@Table(
+    name = "look_products",
+    uniqueConstraints = [
+        UniqueConstraint(columnNames = ["look_id", "product_id"]),
+        UniqueConstraint(columnNames = ["look_id", "display_order"])
+    ],
+)
+class LookProduct(
+    @Id
+    @Column(name = "id")
+    val id: Long,
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "look_id", nullable = false, updatable = false)
+    val look: Look,
+
+    @Column(name = "product_id", nullable = false, updatable = false)
+    val productId: Long,
+
+    @Column(name = "display_order", nullable = false)
+    val displayOrder: Int,
+) {
+
+    companion object {
+        fun of(
+            look: Look,
+            productId: Long,
+            displayOrder: Int
+        ) = LookProduct(
+                id = IdGenerator.generate(),
+                look = look,
+                productId = productId,
+                displayOrder = displayOrder,
+            )
+    }
+}