Merge pull request #70 from lee-ji-hoon/kms

[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)
+    }
+}

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

@@ -0,0 +1,12 @@
+package kms.chapter14
+
+class Phone {
+
+    fun calculateFee() {
+
+    }
+
+    fun getCalls(): List<Call> {
+        return emptyList()
+    }
+}

src/main/kotlin/kms/chapter14/README.md

@@ -0,0 +1,23 @@
+### 설계시 유의할 점
+
+- 유사한 기능을 구현하기 위해 유사한 협력 패턴을 사용하기
+	- 일관성 있는  패턴을 따르면 이해하고 확장하기 쉬워진다
+
+### 캡슐화
+
+- 코드 수정으로 인한 파급효과를 제어할 수 있는 모든 기법
+	- **데이터 은닉** 뿐이 아니다
+- **데이터 캡슐화**
+	- 내부에서 관리하는 데이터를 캡슐화
+- **메서드 캡슐화**
+	- 클래스의 내부 행동을 캡슐화
+- **객체 캡슐화**
+	- 객체의 관계를 캡슐화 한다 (합성)
+- **서브타입 캡슐화**
+	- 실제 협력하는 객체를 캡슐화 한다.
+	- 다형성의 기반
+
+#### 캡슐화 방법
+
+- 변하는 부분을 분리해서 타입 계층을 만든다
+- 변하지 않는 부분의 일부로 타입 계층을 합성한다

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

@@ -0,0 +1,9 @@
+package kms.chapter14
+
+import kms.chapter14.Money
+import kms.chapter14.Phone
+
+interface RatePolicy {
+
+    fun calculateFee(phone: Phone) : Money
+}

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

@@ -0,0 +1,29 @@
+package kms.chapter14
+
+import java.time.LocalDateTime
+import java.time.LocalTime
+
+class TimeOfDayFeeCondition(
+    private val from: LocalTime,
+    private val to: LocalTime,
+) : FeeCondition {
+
+    override fun findTimeIntervals(call: Call): List<DateTimeInterval> {
+        return call.interval.splitByDay()
+            .filter { from(it).isBefore(to(it)) }
+            .map {
+                DateTimeInterval.of(
+                    LocalDateTime.of(it.from.toLocalDate(), from(it)),
+                    LocalDateTime.of(it.to.toLocalDate(), to(it)),
+                )
+            }
+    }
+
+    private fun from(interval: DateTimeInterval): LocalTime {
+        return if(interval.from.toLocalTime().isBefore(from)) from else interval.from.toLocalTime()
+    }
+
+    private fun to(interval: DateTimeInterval): LocalTime {
+        return if(interval.to.toLocalTime().isAfter(to)) to else interval.to.toLocalTime()
+    }
+}