[14장_김명석] 내용 정리

Author: audxo112

src/main/kotlin/kms/chapter14/BasicRatePolicy.kt

@@ -0,0 +1,18 @@
+package kms.chapter14
+
+abstract class BasicRatePolicy(
+    private val feeRules: List<FeeRule>
+) : RatePolicy {
+
+    override fun calculateFee(phone: Phone): Money {
+        return phone.getCalls()
+            .map { call -> calculate(call) }
+            .reduce { acc, money -> acc + money }
+    }
+
+    private fun calculate(call: Call): Money {
+        return feeRules
+            .map { rule -> rule.calculateFee(call) }
+            .reduce { acc, money -> acc + money }
+    }
+}

src/main/kotlin/kms/chapter14/Call.kt

@@ -0,0 +1,19 @@
+package kms.chapter14
+
+import java.time.Duration
+import java.time.LocalDateTime
+
+data class Call(
+    val interval: DateTimeInterval,
+) {
+    val duration: Duration
+        get() = interval.duration
+
+    val from: LocalDateTime
+        get() = interval.from
+
+    val to: LocalDateTime
+        get() = interval.to
+
+    fun splitByDay() : List<DateTimeInterval> = interval.splitByDay()
+}

src/main/kotlin/kms/chapter14/DateTimeInterval.kt

@@ -0,0 +1,60 @@
+package kms.chapter14
+
+import java.time.Duration
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+
+class DateTimeInterval(
+    val from: LocalDateTime,
+    val to: LocalDateTime,
+) {
+    companion object {
+        fun of(from: LocalDateTime, to: LocalDateTime) = DateTimeInterval(from, to)
+
+        fun toMidnight(from: LocalDateTime): DateTimeInterval {
+            return DateTimeInterval(
+                from,
+                LocalDateTime.of(from.toLocalDate(), LocalTime.of(23, 59, 59, 999_999_999))
+            )
+        }
+
+        fun fromMidnight(to: LocalDateTime): DateTimeInterval {
+            return DateTimeInterval(
+                LocalDateTime.of(to.toLocalDate(), LocalTime.of(0, 0)),
+                to
+            )
+        }
+
+        fun during(date: LocalDate): DateTimeInterval {
+            return DateTimeInterval(
+                LocalDateTime.of(date, LocalTime.of(0, 0)),
+                LocalDateTime.of(date, LocalTime.of(23, 59, 59, 999_999_999))
+            )
+        }
+    }
+
+    val duration
+        get() = Duration.between(from, to)
+
+    fun splitByDay(): List<DateTimeInterval> {
+        if (days > 0) {
+            return splitByDay(days)
+        }
+        return listOf(this)
+    }
+
+    private fun splitByDay(days: Long): List<DateTimeInterval> {
+        return mutableListOf<DateTimeInterval>().apply {
+            add(toMidnight(from))
+            for (loop in 1 until days) {
+                add(during(from.toLocalDate().plusDays(loop)))
+            }
+            add(fromMidnight(to))
+        }
+
+    }
+
+    private val days
+        get() = Duration.between(from.toLocalDate().atStartOfDay(), to.toLocalDate().atStartOfDay()).toDays()
+}

src/main/kotlin/kms/chapter14/DayOfWeekFeeCondition.kt

@@ -0,0 +1,13 @@
+package kms.chapter14
+
+import java.time.DayOfWeek
+
+class DayOfWeekFeeCondition(
+    private val dayOfWeeks: List<DayOfWeek>
+) : FeeCondition {
+
+    override fun findTimeIntervals(call: Call): List<DateTimeInterval> {
+        return call.interval.splitByDay()
+            .filter { dayOfWeeks.contains(it.from.dayOfWeek) }
+    }
+}

src/main/kotlin/kms/chapter14/DurationFeeCondition.kt

@@ -0,0 +1,26 @@
+package kms.chapter14
+
+import java.time.Duration
+
+class DurationFeeCondition(
+    private val from: Duration,
+    private val to: Duration,
+) : FeeCondition {
+
+    override fun findTimeIntervals(call: Call): List<DateTimeInterval> {
+        if (call.interval.duration < from) {
+            return emptyList()
+        }
+
+        return listOf(
+            DateTimeInterval.of(
+                call.interval.from + from,
+                if (call.interval.duration > to) {
+                    call.interval.from + to
+                } else {
+                    call.interval.to
+                }
+            )
+        )
+    }
+}

src/main/kotlin/kms/chapter14/FeeCondition.kt

@@ -0,0 +1,6 @@
+package kms.chapter14
+
+interface FeeCondition {
+
+    fun findTimeIntervals(call: Call): List<DateTimeInterval>
+}

src/main/kotlin/kms/chapter14/FeePerDuration.kt

@@ -0,0 +1,14 @@
+package kms.chapter14
+
+import java.time.Duration
+import kotlin.math.ceil
+
+class FeePerDuration(
+    private val fee: Money,
+    private val duration: Duration,
+) {
+
+    fun calculate(interval: DateTimeInterval): Money {
+        return fee * (ceil(interval.duration.toNanos().toDouble() / duration.toNanos()))
+    }
+}

src/main/kotlin/kms/chapter14/FeeRule.kt

@@ -0,0 +1,13 @@
+package kms.chapter14
+
+class FeeRule(
+    private val feeCondition: FeeCondition,
+    private val feePerDuration: FeePerDuration,
+) {
+
+    fun calculateFee(call: Call): Money {
+        return feeCondition.findTimeIntervals(call)
+            .map { feePerDuration.calculate(it) }
+            .reduce { acc, money -> acc + money }
+    }
+}

src/main/kotlin/kms/chapter14/FixedFeeCondition.kt

@@ -0,0 +1,8 @@
+package kms.chapter14
+
+class FixedFeeCondition : FeeCondition {
+
+    override fun findTimeIntervals(call: Call): List<DateTimeInterval> {
+        return listOf(call.interval)
+    }
+}

src/main/kotlin/kms/chapter14/Money.kt

@@ -0,0 +1,41 @@
+package kms.chapter14
+
+import java.math.BigDecimal
+
+class Money(
+    private val amount: BigDecimal,
+) : Comparable<Money> {
+    operator fun plus(amount: Money): Money {
+        return Money(this.amount.add(amount.amount))
+    }
+
+    operator fun minus(amount: Money): Money {
+        return Money(this.amount.subtract(amount.amount))
+    }
+
+    operator fun times(percent: Double): Money {
+        return Money(this.amount.multiply(BigDecimal.valueOf(percent)))
+    }
+
+    operator fun times(percent: Float): Money {
+        return Money(this.amount.multiply(BigDecimal.valueOf(percent.toDouble())))
+    }
+
+    operator fun times(value: Int): Money {
+        return Money(this.amount.multiply(BigDecimal.valueOf(value.toLong())))
+    }
+
+    operator fun times(value: Long): Money {
+        return Money(this.amount.multiply(BigDecimal.valueOf(value)))
+    }
+
+    override fun compareTo(other: Money): Int {
+        return amount.compareTo(other.amount)
+    }
+
+    companion object {
+        fun wons(amount: Long) = Money(BigDecimal.valueOf(amount))
+
+        val ZERO = wons(0)
+    }
+}