Domain-Driven Design

// Demo Domain-Driven Design: strategic (bounded contexts) + tactical (entities, value objects, aggregates, repositories).

import java.time.LocalDate

// === STRATEGIC DESIGN ===

// Bounded Context: Pengiriman
// Di sini, "Alamat" punya atribut jalan, kota, kode pos
data class AlamatPengiriman(val jalan: String, val kota: String, val kodePos: String)

// Bounded Context: Penagihan
// Di sini, "Alamat" punya atribut untuk penagihan (bisa beda dengan pengiriman)
data class AlamatPenagihan(val pemegang: String, val jalan: String, val kota: String)

// Bounded Context: Inventaris
// Di sini, "Produk" punya SKU dan stok; tidak peduli dengan harga jual
data class ProdukInventaris(val sku: String, val stok: Int)

// Bounded Context: Penjualan
// Di sini, "Produk" punya harga jual; tidak peduli dengan stok
data class ProdukPenjualan(val id: Int, val nama: String, val harga: Double)

// === TACTICAL DESIGN ===

// Value Object: immutable, dibandingkan dari nilai
@JvmInline
value class Uang(val nilai: Double) {
    operator fun plus(lain: Uang) = Uang(nilai + lain.nilai)
    operator fun minus(lain: Uang) = Uang(nilai - lain.nilai)
}

// Entity: mutable, punya identitas (id)
class Pelanggan(val id: Int, var nama: String, var alamatEmail: String) {
    override fun equals(other: Any?) = other is Pelanggan && other.id == id
    override fun hashCode() = id
}

// Aggregate Root: Pesanan mengontrol konsistensi ItemPesanan
class Pesanan(val id: Int, val pelangganId: Int) {
    private val items = mutableListOf<ItemPesanan>()
    private var status: StatusPesanan = StatusPesanan.DRAFT

    fun tambahItem(produk: ProdukPenjualan, jumlah: Int) {
        require(status == StatusPesanan.DRAFT) { "Pesanan sudah tidak dalam status DRAFT" }
        require(jumlah > 0) { "Jumlah harus positif" }
        items.add(ItemPesanan(produk, jumlah))
    }

    fun total(): Uang = items.fold(Uang(0.0)) { acc, i -> acc + i.subtotal() }

    fun checkout() {
        require(items.isNotEmpty()) { "Pesanan kosong" }
        status = StatusPesanan.DIPROSES
    }

    fun ringkas() = "Pesanan #$id pelanggan=$pelangganId ${items.size} item total=${total().nilai} status=$status"
}

data class ItemPesanan(val produk: ProdukPenjualan, val jumlah: Int) {
    fun subtotal(): Uang = Uang(produk.harga * jumlah)
}

enum class StatusPesanan { DRAFT, DIPROSES, DIKIRIM, SELESAI }

// Repository: abstraksi akses data
interface PesananRepository {
    fun simpan(pesanan: Pesanan)
    fun cari(id: Int): Pesanan?
    fun semua(): List<Pesanan>
}

class InMemoryPesananRepository : PesananRepository {
    private val store = mutableMapOf<Int, Pesanan>()
    override fun simpan(pesanan: Pesanan) { store[pesanan.id] = pesanan }
    override fun cari(id: Int): Pesanan? = store[id]
    override fun semua(): List<Pesanan> = store.values.toList()
}

// Domain Service: logika yang melibatkan beberapa aggregate
class LayananPengiriman {
    fun kirim(pesanan: Pesanan, alamat: AlamatPengiriman): String {
        require(pesanan.total().nilai > 0) { "Total harus positif" }
        return "Pesanan #${pesanan.id} dikirim ke ${alamat.jalan}, ${alamat.kota}"
    }
}

// Ubiquitous Language: istilah bisnis yang dipakai konsisten di kode dan diskusi tim
// Pesanan, Pelanggan, ItemPesanan, Checkout, DIPROSES, DIKIRIM, SELESAI

fun main() {
    println("=== Demo Domain-Driven Design ===")

    // Strategic: bounded context terpisah
    val produkInv = ProdukInventaris("BK001", 100)
    val produkJual = ProdukPenjualan(1, "Buku Kotlin", 75_000.0)
    println("Inventaris: ${produkInv.sku} stok=${produkInv.stok}")
    println("Penjualan: ${produkJual.id} harga=${produkJual.harga}")

    println()
    println("--- Tactical: aggregate root ---")
    val pelanggan = Pelanggan(1, "Budi", "[email protected]")
    val p = Pesanan(101, pelanggan.id)
    p.tambahItem(produkJual, 2)
    p.tambahItem(ProdukPenjualan(2, "Pulpen", 5_000.0), 3)
    println(p.ringkas())

    p.checkout()
    println(p.ringkas())

    println()
    println("--- Tactical: repository ---")
    val repo = InMemoryPesananRepository()
    repo.simpan(p)
    println("Cari pesanan #101: ${repo.cari(101)?.ringkas()}")
    println("Total pesanan di repo: ${repo.semua().size}")

    println()
    println("--- Tactical: domain service ---")
    val alamat = AlamatPengiriman("Jl. Merdeka 10", "Jakarta", "10000")
    val pengiriman = LayananPengiriman()
    println(pengiriman.kirim(p, alamat))
}

=== Demo Domain-Driven Design ===
Inventaris: BK001 stok=100
Penjualan: 1 harga=75000.0

--- Tactical: aggregate root ---
Pesanan #101 pelanggan=1 2 item total=165000.0 status=DRAFT
Pesanan #101 pelanggan=1 2 item total=165000.0 status=DIPROSES

--- Tactical: repository ---
Cari pesanan #101: Pesanan #101 pelanggan=1 2 item total=165000.0 status=DIPROSES
Total pesanan di repo: 1

--- Tactical: domain service ---
Pesanan #101 dikirim ke Jl. Merdeka 10, Jakarta