Merge pull request #1740 from navikt/fjern-comparable-fra-datointervall

fjern comparable for datointervall

Author: hestad

common/domain/src/main/kotlin/no/nav/su/se/bakover/common/domain/Stønadsperiode.kt

@@ -11,7 +11,7 @@ import java.time.Year
 
 data class Stønadsperiode private constructor(
     val periode: Periode,
-) : Comparable<Stønadsperiode> {
+) {
 
     infix fun inneholder(periode: Periode) = this.periode.inneholder(periode)
     infix fun inneholder(stønadsperiode: Stønadsperiode) = this.periode.inneholder(stønadsperiode.periode)
@@ -40,7 +40,6 @@ data class Stønadsperiode private constructor(
         data object FraOgMedDatoKanIkkeVæreFør2021 : UgyldigStønadsperiode
     }
 
-    override fun compareTo(other: Stønadsperiode) = periode.compareTo(other.periode)
     fun måneder() = periode.måneder()
     fun toYearRange(): YearRange = YearRange(Year.of(this.periode.fraOgMed.year), Year.of(this.periode.tilOgMed.year))
 }

common/domain/src/main/kotlin/no/nav/su/se/bakover/common/domain/tid/periode/DatoIntervall.kt

@@ -2,7 +2,6 @@ package no.nav.su.se.bakover.common.tid.periode
 
 import arrow.core.Either
 import arrow.core.NonEmptyList
-import arrow.core.getOrElse
 import arrow.core.left
 import arrow.core.right
 import java.time.LocalDate
@@ -18,15 +17,15 @@ import java.util.Locale
 open class DatoIntervall(
     val fraOgMed: LocalDate,
     val tilOgMed: LocalDate,
-) : Comparable<DatoIntervall> {
+) {
 
     init {
         require(fraOgMed <= tilOgMed) {
             "fraOgMed må være før eller samme dag som tilOgMed"
         }
     }
 
-    override fun compareTo(other: DatoIntervall) = compareValuesBy(this, other, { it.fraOgMed }, { it.tilOgMed })
+    constructor(dato: LocalDate) : this(dato, dato)
 
     infix fun inneholder(dato: LocalDate): Boolean = dato in fraOgMed..tilOgMed
 
@@ -92,12 +91,24 @@ open class DatoIntervall(
         return this == other || sluttStart == plussEnDag || sluttStart == minusEnDag || startSlutt == plussEnDag || startSlutt == minusEnDag
     }
 
+    infix fun tilstøter(other: LocalDate): Boolean {
+        val dayBeforeStart = fraOgMed.minusDays(1)
+        val dayAfterEnd = tilOgMed.plusDays(1)
+        return other.isEqual(dayBeforeStart) || other.isEqual(dayAfterEnd)
+    }
+
     infix fun slåSammen(
         other: DatoIntervall,
     ): Either<DatoIntervallKanIkkeSlåsSammen, DatoIntervall> {
         return slåSammen(other) { fraOgMed, tilOgMed -> DatoIntervall(fraOgMed, tilOgMed) }
     }
 
+    infix fun slåSammen(
+        other: LocalDate,
+    ): Either<DatoIntervallKanIkkeSlåsSammen, DatoIntervall> {
+        return slåSammen(DatoIntervall(other, other)) { fraOgMed, tilOgMed -> DatoIntervall(fraOgMed, tilOgMed) }
+    }
+
     /**
      * Slår sammen to perioder dersom minst en måned overlapper eller periodene er tilstøtende.
      */
@@ -115,6 +126,13 @@ open class DatoIntervall(
         }
     }
 
+    /**
+     * @return Liste med alle dager i [DatoIntervall], sortert og unike.
+     */
+    fun dager(): List<LocalDate> {
+        return (0 until antallDager()).map { fraOgMed.plusDays(it) }
+    }
+
     /**
      * Periode i formatet "dd.MM.yyyy - dd.MM.yyyy".
      */
@@ -123,10 +141,15 @@ open class DatoIntervall(
         return "${this.fraOgMed.format(formatter)} - ${this.tilOgMed.format(formatter)}"
     }
 
-    override fun equals(other: Any?) = other is DatoIntervall && fraOgMed == other.fraOgMed && tilOgMed == other.tilOgMed
+    override fun equals(other: Any?) =
+        other is DatoIntervall && fraOgMed == other.fraOgMed && tilOgMed == other.tilOgMed
 
     override fun hashCode() = 31 * fraOgMed.hashCode() + tilOgMed.hashCode()
 
+    override fun toString(): String {
+        return "DatoIntervall(fraOgMed=$fraOgMed, tilOgMed=$tilOgMed)"
+    }
+
     data object DatoIntervallKanIkkeSlåsSammen
 }
 
@@ -141,19 +164,21 @@ fun List<DatoIntervall>.minsteAntallSammenhengendePerioder(): List<DatoIntervall
 fun <T : DatoIntervall> List<T>.minsteAntallSammenhengendePerioder(
     create: (fraOgMed: LocalDate, tilOgMed: LocalDate) -> T,
 ): List<T> {
-    return sorted().fold(mutableListOf()) { slåttSammen: MutableList<T>, datoIntervall: T ->
-        if (slåttSammen.isEmpty()) {
-            slåttSammen.add(datoIntervall)
-        } else if (slåttSammen.last().slåSammen(datoIntervall).isRight()) {
-            val last = slåttSammen.removeLast()
-            slåttSammen.add(
-                last.slåSammen(datoIntervall, create).getOrElse { throw IllegalStateException("Skulle gått bra") },
-            )
-        } else {
-            slåttSammen.add(datoIntervall)
+    return this.dager()
+        .fold(emptyList()) { acc, dato ->
+            if (acc.isEmpty()) {
+                listOf(DatoIntervall(dato, dato))
+            } else {
+                acc.last().slåSammen(dato).fold(
+                    { acc + listOf(DatoIntervall(dato, dato)) },
+                    { acc.dropLast(1) + it },
+                )
+            }.let {
+                it.map {
+                    create(it.fraOgMed, it.tilOgMed)
+                }
+            }
         }
-        slåttSammen
-    }
 }
 
 infix fun List<DatoIntervall>.inneholder(other: List<DatoIntervall>): Boolean =
@@ -176,3 +201,10 @@ fun List<DatoIntervall>.minAndMaxOfOrNull(): DatoIntervall? {
         tilOgMed = this.maxOf { it.tilOgMed },
     )
 }
+
+/**
+ * @return Liste med alle dager i alle [DatoIntervall] i listen, sortert og unike.
+ */
+fun <T : DatoIntervall> List<T>.dager(): List<LocalDate> {
+    return this.flatMap { it.dager() }.distinct().sorted()
+}

common/domain/src/main/kotlin/no/nav/su/se/bakover/common/domain/tid/periode/Måned.kt

@@ -24,6 +24,8 @@ data class Måned private constructor(
             require(this.før(that))
         }
     }
+    // TODO - her vil vi ha en egen compareTo og comaprable på måned
+    // override fun compareTo(other: Måned): Int = this.årOgMåned.compareTo(other.årOgMåned)
 
     /**
      * Returns a range from this value up to but excluding the specified to value.

common/domain/src/main/kotlin/no/nav/su/se/bakover/common/domain/tid/periode/Periode.kt

@@ -27,7 +27,7 @@ import kotlin.collections.minus as setsMinus
 open class Periode protected constructor(
     fraOgMed: LocalDate,
     tilOgMed: LocalDate,
-) : DatoIntervall(fraOgMed, tilOgMed) {
+) : DatoIntervall(fraOgMed, tilOgMed), Comparable<Periode> {
 
     constructor(måned: YearMonth) : this(måned.atDay(1), måned.atEndOfMonth()) {
         validateOrThrow(fraOgMed, tilOgMed)
@@ -37,6 +37,8 @@ open class Periode protected constructor(
         validateOrThrow(fraOgMed, tilOgMed)
     }
 
+    override fun compareTo(other: Periode) = compareValuesBy(this, other, Periode::fraOgMed, Periode::tilOgMed)
+
     /**
      * @throws IllegalStateException dersom fraOgMed er LocalDate.MIN eller tilOgMed er LocalDate.MAX
      * @throws ArithmeticException dersom antall måneder er større enn en Int.
@@ -198,7 +200,16 @@ fun List<Periode>.minAndMaxOfOrNull(): Periode? {
  * definert av [Periode.slåSammen].
  */
 fun List<Periode>.minsteAntallSammenhengendePerioder(): List<Periode> {
-    return minsteAntallSammenhengendePerioder { fraOgMed, tilOgMed -> Periode.create(fraOgMed, tilOgMed) }
+    return this.måneder().fold(emptyList()) { acc, måned ->
+        if (acc.isEmpty()) {
+            listOf(måned.tilPeriode())
+        } else {
+            acc.last().slåSammen(måned.tilPeriode()).fold(
+                { acc + måned.tilPeriode() },
+                { acc.dropLast(1) + it },
+            )
+        }
+    }
 }
 
 fun Nel<Periode>.minsteAntallSammenhengendePerioder(): Nel<Periode> {

common/domain/src/test/kotlin/no/nav/su/se/bakover/common/domain/periode/DatoIntervallTest.kt

@@ -1,7 +1,5 @@
 package no.nav.su.se.bakover.common.domain.periode
 
-import io.kotest.matchers.ints.shouldBeGreaterThan
-import io.kotest.matchers.ints.shouldBeLessThan
 import io.kotest.matchers.shouldBe
 import no.nav.su.se.bakover.common.extensions.april
 import no.nav.su.se.bakover.common.extensions.august
@@ -27,13 +25,6 @@ import org.junit.jupiter.api.Test
 
 internal class DatoIntervallTest {
 
-    @Test
-    fun compareTo() {
-        DatoIntervall(1.januar(2021), 31.januar(2021)).compareTo(DatoIntervall(1.januar(2021), 31.januar(2021))) shouldBe 0
-        DatoIntervall(1.januar(2021), 31.januar(2021)).compareTo(DatoIntervall(1.januar(2021), 31.desember(2021))).shouldBeLessThan(0)
-        DatoIntervall(1.januar(2021), 31.januar(2021)).compareTo(DatoIntervall(1.januar(2021), 1.januar(2021))).shouldBeGreaterThan(0)
-    }
-
     @Test
     fun inneholder() {
         DatoIntervall(

common/domain/src/test/kotlin/no/nav/su/se/bakover/common/domain/periode/DatoIntervall_dagerTest.kt

@@ -0,0 +1,84 @@
+package no.nav.su.se.bakover.common.domain.periode
+
+import io.kotest.matchers.shouldBe
+import no.nav.su.se.bakover.common.extensions.april
+import no.nav.su.se.bakover.common.extensions.august
+import no.nav.su.se.bakover.common.extensions.desember
+import no.nav.su.se.bakover.common.extensions.februar
+import no.nav.su.se.bakover.common.extensions.januar
+import no.nav.su.se.bakover.common.extensions.juli
+import no.nav.su.se.bakover.common.extensions.juni
+import no.nav.su.se.bakover.common.extensions.mai
+import no.nav.su.se.bakover.common.extensions.mars
+import no.nav.su.se.bakover.common.extensions.november
+import no.nav.su.se.bakover.common.extensions.oktober
+import no.nav.su.se.bakover.common.extensions.september
+import no.nav.su.se.bakover.common.tid.periode.DatoIntervall
+import no.nav.su.se.bakover.common.tid.periode.dager
+import no.nav.su.se.bakover.common.tid.periode.januar
+import no.nav.su.se.bakover.common.tid.periode.år
+import org.junit.jupiter.api.Test
+
+internal class DatoIntervall_dagerTest {
+
+    @Test
+    fun `ingen dager`() {
+        listOf<DatoIntervall>().dager() shouldBe emptyList()
+    }
+
+    @Test
+    fun `1 dag`() {
+        DatoIntervall(1.januar(2022), 1.januar(2022)).dager() shouldBe listOf(1.januar(2022))
+
+        listOf(
+            DatoIntervall(1.januar(2022), 1.januar(2022)),
+            DatoIntervall(1.januar(2022), 1.januar(2022)),
+        ).dager() shouldBe listOf(1.januar(2022))
+    }
+
+    @Test
+    fun `2 dager`() {
+        DatoIntervall(1.januar(2022), 2.januar(2022)).dager() shouldBe
+            listOf(1.januar(2022), 2.januar(2022))
+
+        listOf(
+            DatoIntervall(1.januar(2022), 1.januar(2022)),
+            DatoIntervall(1.januar(2022), 2.januar(2022)),
+            DatoIntervall(2.januar(2022), 2.januar(2022)),
+        ).dager() shouldBe listOf(1.januar(2022), 2.januar(2022))
+
+        listOf(
+            DatoIntervall(1.januar(2022), 1.januar(2022)),
+            DatoIntervall(2.januar(2022), 2.januar(2022)),
+        ).dager() shouldBe listOf(1.januar(2022), 2.januar(2022))
+    }
+
+    @Test
+    fun `1 måned`() {
+        januar(2022).dager() shouldBe
+            (1..31).map { it.januar(2022) }
+    }
+
+    @Test
+    fun `1 år`() {
+        val expected = (1..31).map { it.januar(2022) } +
+            (1..28).map { it.februar(2022) } +
+            (1..31).map { it.mars(2022) } +
+            (1..30).map { it.april(2022) } +
+            (1..31).map { it.mai(2022) } +
+            (1..30).map { it.juni(2022) } +
+            (1..31).map { it.juli(2022) } +
+            (1..31).map { it.august(2022) } +
+            (1..30).map { it.september(2022) } +
+            (1..31).map { it.oktober(2022) } +
+            (1..30).map { it.november(2022) } +
+            (1..31).map { it.desember(2022) }
+        år(2022).dager() shouldBe expected
+        listOf(
+            år(2022),
+            januar(2022),
+            DatoIntervall(3.juli(2022), 3.juli(2022)),
+            DatoIntervall(7.februar(2022), 18.august(2022)),
+        ).dager() shouldBe expected
+    }
+}