feat: 예약 도메인 추가 및 패키지 도메인 일부 변경

src/main/kotlin/com/study/core/product/domain/ProductRepository.kt

@@ -1,4 +1,6 @@
 package com.study.core.product.domain
 
 interface ProductRepository {
+
+    fun findAllByIdIn(productIds: List<Long>): List<Product>
 }

src/main/kotlin/com/study/core/product/infrastructure/ProductJpaRepository.kt

@@ -4,4 +4,6 @@ import com.study.core.product.domain.Product
 import org.springframework.data.repository.CrudRepository
 
 interface ProductJpaRepository : CrudRepository<Product, Long> {
+
+    fun findAllByIdIn(productIds: List<Long>): List<Product>
 }

src/main/kotlin/com/study/core/product/infrastructure/ProductRepositoryImpl.kt

@@ -1,10 +1,15 @@
 package com.study.core.product.infrastructure
 
+import com.study.core.product.domain.Product
 import com.study.core.product.domain.ProductRepository
 import org.springframework.stereotype.Repository
 
 @Repository
 class ProductRepositoryImpl(
     private val productJpaRepository: ProductJpaRepository
 ) : ProductRepository {
+
+    override fun findAllByIdIn(productIds: List<Long>): List<Product> {
+        return productJpaRepository.findAllByIdIn(productIds)
+    }
 }

src/main/kotlin/com/study/core/productpackage/application/PackageCommandService.kt

@@ -1,16 +1,39 @@
 package com.study.core.productpackage.application
 
+import com.study.core.product.domain.Product
+import com.study.core.product.domain.ProductRepository
+import com.study.core.productpackage.application.dto.CreatePackageCommand
+import com.study.core.productpackage.domain.Package
+import com.study.core.productpackage.infrastructure.PackageCommandRepository
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 
-/**
- * TODO : 도메인 설계 Merge이후 작업
- */
 @Transactional
 @Service
-class PackageCommandService {
+class PackageCommandService(
+    private val packageCommandRepository: PackageCommandRepository,
+    private val productRepository: ProductRepository,
+) {
 
-    fun createPackage(): Package {
-        TODO()
+    fun createPackage(command: CreatePackageCommand): Package {
+        val products = findProducts(command.productIds)
+        val pkg = Package.createWithTimeSlots(
+            name = command.name,
+            description = command.description,
+            products = products,
+            tagNames = command.tagNames,
+            slotStartDate = command.slotStartDate,
+            slotEndDate = command.slotEndDate,
+            slotStartHour = command.slotStartHour,
+            slotEndHour = command.slotEndHour
+        )
+
+        return packageCommandRepository.save(pkg)
+    }
+
+    private fun findProducts(productIds: List<Long>): List<Product> {
+        val products = productRepository.findAllByIdIn(productIds)
+        require(products.size == productIds.size) { "One or more products are not found." }
+        return products
     }
 }

src/main/kotlin/com/study/core/productpackage/application/dto/CreatePackageCommand.kt

@@ -0,0 +1,14 @@
+package com.study.core.productpackage.application.dto
+
+import java.time.LocalDate
+
+data class CreatePackageCommand(
+    val name: String,
+    val description: String,
+    val slotStartDate: LocalDate, // 패키지 생성 시 예약 시작 가능한 날짜
+    val slotEndDate: LocalDate, // 패키지 생성 시 패키지 마감 날짜
+    val slotStartHour: Int = 9, // 예약 가능한 타임 슬롯 시작 지점
+    val slotEndHour: Int = 16, // 예약 가능한 타임 슬록 마지막 지점
+    val productIds: List<Long> = emptyList(), // 예약에 포함할 패키지 ids
+    val tagNames: List<String> = emptyList() // 패키지에 해당하는 tags
+)

src/main/kotlin/com/study/core/productpackage/domain/Package.kt

@@ -1,6 +1,8 @@
 package com.study.core.productpackage.domain
 
 import com.study.core.global.BaseEntity
+import com.study.core.product.domain.Product
+import com.study.core.reservation.domain.ReservationSlot
 import jakarta.persistence.CascadeType
 import jakarta.persistence.Column
 import jakarta.persistence.Entity
@@ -12,6 +14,8 @@ import jakarta.persistence.OneToMany
 import jakarta.persistence.Table
 import jakarta.persistence.Transient
 import java.math.BigDecimal
+import java.time.LocalDate
+import java.time.LocalTime
 
 @Entity
 @Table(name = "packages")
@@ -26,11 +30,14 @@ class Package(
     @Column(nullable = false, columnDefinition = "TEXT")
     val description: String,
 
-    @OneToMany(mappedBy = "pkg", cascade = [CascadeType.PERSIST], orphanRemoval = true, fetch = FetchType.LAZY)
+    @OneToMany(mappedBy = "pkg", cascade = [CascadeType.ALL], orphanRemoval = true, fetch = FetchType.LAZY)
     val packageProducts: MutableList<PackageProduct> = mutableListOf(),
 
-    @OneToMany(mappedBy = "pkg", cascade = [CascadeType.PERSIST], orphanRemoval = true, fetch = FetchType.LAZY)
+    @OneToMany(mappedBy = "pkg", cascade = [CascadeType.ALL], orphanRemoval = true, fetch = FetchType.LAZY)
     val packageTags: MutableList<PackageTag> = mutableListOf(),
+
+    @OneToMany(mappedBy = "pkg", cascade = [CascadeType.ALL], orphanRemoval = true, fetch = FetchType.LAZY)
+    val reservationSlots: MutableList<ReservationSlot> = mutableListOf(),
 ) : BaseEntity() {
 
     @get:Transient
@@ -45,4 +52,81 @@ class Package(
         get() = packageProducts.fold(BigDecimal.ZERO) { totalPrice, packageProduct ->
             totalPrice + packageProduct.product.price
         }
+
+    fun addProducts(products: Collection<Product>) {
+        products.distinctBy { it.id }
+            .forEach { product ->
+                packageProducts.add(PackageProduct(pkg = this, product = product))
+            }
+    }
+
+    fun addTags(tagNames: Collection<String>) {
+        tagNames.map { it.trim() }
+            .filter { it.isNotEmpty() }
+            .distinct()
+            .forEach { name ->
+                packageTags.add(PackageTag(pkg = this, tagName = name))
+            }
+    }
+
+    fun addReservationSlots(
+        startDate: LocalDate,
+        endDate: LocalDate,
+        startHour: Int = DEFAULT_RESERVATION_START_HOUR,
+        endHour: Int = DEFAULT_RESERVATION_END_HOUR
+    ) {
+        require(!endDate.isBefore(startDate)) { "endDate must not be before startDate." }
+        require(
+            startHour in DEFAULT_RESERVATION_START_HOUR..(DEFAULT_RESERVATION_END_HOUR - 1) &&
+                    endHour in (DEFAULT_RESERVATION_START_HOUR + 1)..DEFAULT_RESERVATION_END_HOUR &&
+                    startHour < endHour
+        ) { "Slot hours must be between 09 and 16." }
+
+        var currentDate = startDate
+        while (!currentDate.isAfter(endDate)) {
+            for (hour in startHour until endHour) {
+                val startTime = LocalTime.of(hour, 0)
+                val endTime = startTime.plusHours(1)
+                reservationSlots.add(
+                    ReservationSlot(
+                        pkg = this,
+                        reservationDate = currentDate,
+                        startTime = startTime,
+                        endTime = endTime
+                    )
+                )
+            }
+            currentDate = currentDate.plusDays(1)
+        }
+    }
+
+    companion object {
+        const val DEFAULT_RESERVATION_START_HOUR = 9
+        const val DEFAULT_RESERVATION_END_HOUR = 16
+
+        fun createWithTimeSlots(
+            name: String,
+            description: String,
+            products: Collection<Product>,
+            tagNames: Collection<String>,
+            slotStartDate: LocalDate,
+            slotEndDate: LocalDate,
+            slotStartHour: Int = DEFAULT_RESERVATION_START_HOUR,
+            slotEndHour: Int = DEFAULT_RESERVATION_END_HOUR
+        ): Package {
+            val pkg = Package(
+                name = name,
+                description = description
+            )
+            pkg.addProducts(products)
+            pkg.addTags(tagNames)
+            pkg.addReservationSlots(
+                startDate = slotStartDate,
+                endDate = slotEndDate,
+                startHour = slotStartHour,
+                endHour = slotEndHour
+            )
+            return pkg
+        }
+    }
 }

src/main/kotlin/com/study/core/productpackage/domain/PackageTag.kt

@@ -1,6 +1,7 @@
 package com.study.core.productpackage.domain
 
 import com.study.core.global.BaseEntity
+import jakarta.persistence.Column
 import jakarta.persistence.Entity
 import jakarta.persistence.FetchType
 import jakarta.persistence.GeneratedValue
@@ -15,7 +16,7 @@ import jakarta.persistence.UniqueConstraint
 @Table(
     name = "package_tag",
     uniqueConstraints = [
-        UniqueConstraint(name = "uk_package_tag", columnNames = ["package_id", "tag_id"])
+        UniqueConstraint(name = "uk_package_tag", columnNames = ["package_id", "tag_name"])
     ]
 )
 class PackageTag(
@@ -27,7 +28,6 @@ class PackageTag(
     @JoinColumn(name = "package_id")
     val pkg: Package,
 
-    @ManyToOne(fetch = FetchType.LAZY, optional = false)
-    @JoinColumn(name = "tag_id")
-    val tag: Tag
+    @Column(name = "tag_name", nullable = false, length = 50)
+    val tagName: String
 ) : BaseEntity()

src/main/kotlin/com/study/core/productpackage/infrastructure/PackageCommandRepository.kt

@@ -1,9 +1,12 @@
 package com.study.core.productpackage.infrastructure
 
+import com.study.core.productpackage.domain.Package
 import org.springframework.stereotype.Repository
 
 @Repository
 class PackageCommandRepository(
     private val packageJpaRepository: PackageJpaRepository
 ) {
+
+    fun save(pkg: Package): Package = packageJpaRepository.save(pkg)
 }

src/main/kotlin/com/study/core/reservation/application/ReservationCommandService.kt

@@ -0,0 +1,41 @@
+package com.study.core.reservation.application
+
+import com.study.core.reservation.application.dto.CreateReservationCommand
+import com.study.core.reservation.domain.Reservation
+import com.study.core.reservation.domain.ReservationRepository
+import com.study.core.reservation.domain.ReservationSlotRepository
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+@Transactional
+@Service
+class ReservationCommandService(
+    private val reservationRepository: ReservationRepository,
+    private val reservationSlotRepository: ReservationSlotRepository
+) {
+
+    fun createReservation(command: CreateReservationCommand): Reservation {
+        val reservationTimeSlot = reservationSlotRepository.findByIdForUpdate(command.reservationSlotId)
+            ?: throw IllegalArgumentException("Reservation slot not found: ${command.reservationSlotId}")
+        reservationTimeSlot.validateBookingStatusAndPackageValid(command.packageId)
+
+        val reservation = Reservation(
+            reservationSlot = reservationTimeSlot,
+            userId = command.userId,
+            headCount = command.headCount,
+            visitDate = reservationTimeSlot.reservationDate,
+            visitStartTime = reservationTimeSlot.startTime,
+            visitEndTime = reservationTimeSlot.endTime,
+            totalPrice = command.totalPrice
+        ).request()
+
+        return reservationRepository.save(reservation)
+    }
+
+    fun cancelReservation(reservationId: Long): Reservation {
+        val reservation = reservationRepository.findById(reservationId)
+            ?: throw IllegalArgumentException("Reservation not found: $reservationId")
+        val updated = reservation.cancel()
+        return reservationRepository.save(updated)
+    }
+}

src/main/kotlin/com/study/core/reservation/application/dto/CreateReservationCommand.kt

@@ -0,0 +1,11 @@
+package com.study.core.reservation.application.dto
+
+import java.math.BigDecimal
+
+data class CreateReservationCommand(
+    val packageId: Long,
+    val reservationSlotId: Long, // 예약 가능한 타임슬롯 id
+    val userId: Long,
+    val headCount: Int, // 인원 수
+    val totalPrice: BigDecimal // 패키지 총액 (반정규화)
+)