Filtrering på INTERVAL med to datoverdier

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/db/EksternFeltverdiOperator.kt

@@ -0,0 +1,13 @@
+package no.nav.k9.los.nyoppgavestyring.query.db
+
+enum class EksternFeltverdiOperator(val kode: String) {
+    EQUALS("EQUALS"),
+    LESS_THAN("LESS_THAN"),
+    GREATER_THAN("GREATER_THAN"),
+    LESS_THAN_OR_EQUALS("LESS_THAN_OR_EQUALS"),
+    GREATER_THAN_OR_EQUALS("GREATER_THAN_OR_EQUALS"),
+    NOT_EQUALS("NOT_EQUALS"),
+    IN("IN"),
+    NOT_IN("NOT_IN"),
+    INTERVAL("RANGE");
+}

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/db/OppgavefilterDatoTypeUtvider.kt

@@ -32,16 +32,15 @@ object OppgavefilterDatoTypeUtvider {
 
         // Oversetter operator til pair med grensebetingelser. null tilsvarer fravær av grensebetingelse
         // Gjøres for å mappe grensebetingelser individuelt for hver verdi - fremfor alle nedre grenser, deretter alle øvre grenser.
-        val nedreØvreGrensebetingelse = when (operator) {
-            FeltverdiOperator.EQUALS.name,
-            FeltverdiOperator.IN.name -> (FeltverdiOperator.GREATER_THAN_OR_EQUALS to FeltverdiOperator.LESS_THAN_OR_EQUALS)
-            FeltverdiOperator.GREATER_THAN_OR_EQUALS.name -> (FeltverdiOperator.GREATER_THAN_OR_EQUALS to null)
-            FeltverdiOperator.GREATER_THAN.name -> (null to FeltverdiOperator.GREATER_THAN)
-            FeltverdiOperator.LESS_THAN_OR_EQUALS.name -> (null to FeltverdiOperator.LESS_THAN_OR_EQUALS)
-            FeltverdiOperator.LESS_THAN.name -> (FeltverdiOperator.LESS_THAN to null)
-            FeltverdiOperator.NOT_EQUALS.name,
-            FeltverdiOperator.NOT_IN.name -> (FeltverdiOperator.LESS_THAN to FeltverdiOperator.GREATER_THAN)
-
+        val nedreØvreGrensebetingelse = when (EksternFeltverdiOperator.valueOf(operator)) {
+            EksternFeltverdiOperator.EQUALS,
+            EksternFeltverdiOperator.IN -> (FeltverdiOperator.GREATER_THAN_OR_EQUALS to FeltverdiOperator.LESS_THAN_OR_EQUALS)
+            EksternFeltverdiOperator.GREATER_THAN_OR_EQUALS -> (FeltverdiOperator.GREATER_THAN_OR_EQUALS to null)
+            EksternFeltverdiOperator.GREATER_THAN -> (null to FeltverdiOperator.GREATER_THAN)
+            EksternFeltverdiOperator.LESS_THAN_OR_EQUALS -> (null to FeltverdiOperator.LESS_THAN_OR_EQUALS)
+            EksternFeltverdiOperator.LESS_THAN -> (FeltverdiOperator.LESS_THAN to null)
+            EksternFeltverdiOperator.NOT_EQUALS,
+            EksternFeltverdiOperator.NOT_IN -> (FeltverdiOperator.LESS_THAN to FeltverdiOperator.GREATER_THAN)
             else -> return listOf(this)
         }
 

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/db/OppgavefilterOperatorUtvider.kt

@@ -27,10 +27,15 @@ object OppgavefilterOperatorUtvider {
             return dto
         }
 
-        val operators = when (FeltverdiOperator.valueOf(dto.operator)) {
-            FeltverdiOperator.IN -> (CombineOperator.OR to FeltverdiOperator.EQUALS)
-            FeltverdiOperator.NOT_IN, FeltverdiOperator.NOT_EQUALS -> (CombineOperator.AND to FeltverdiOperator.NOT_EQUALS)
-            FeltverdiOperator.EQUALS -> (CombineOperator.AND to FeltverdiOperator.EQUALS)
+        val operator = EksternFeltverdiOperator.valueOf(dto.operator)
+        if (operator == EksternFeltverdiOperator.INTERVAL) {
+            return lagInterval(dto)
+        }
+
+        val operators = when (operator) {
+            EksternFeltverdiOperator.IN -> (CombineOperator.OR to FeltverdiOperator.EQUALS)
+            EksternFeltverdiOperator.NOT_IN, EksternFeltverdiOperator.NOT_EQUALS -> (CombineOperator.AND to FeltverdiOperator.NOT_EQUALS)
+            EksternFeltverdiOperator.EQUALS -> (CombineOperator.AND to FeltverdiOperator.EQUALS)
             else -> throw IllegalStateException("Ukjent feltverdiOperator for mengder")
         }
 
@@ -44,4 +49,21 @@ object OppgavefilterOperatorUtvider {
             }
         )
     }
+
+    // Forventer at listen er sortert når intervall er brukt
+    private fun lagInterval(dto: FeltverdiOppgavefilter): CombineOppgavefilter {
+        return CombineOppgavefilter(
+            combineOperator = CombineOperator.AND.name,
+            filtere = listOf(
+                dto.copy(
+                    operator = EksternFeltverdiOperator.GREATER_THAN_OR_EQUALS.name,
+                    verdi = listOf(dto.verdi.first()),
+                ),
+                dto.copy(
+                    operator = EksternFeltverdiOperator.LESS_THAN_OR_EQUALS.name,
+                    verdi = listOf(dto.verdi.last()),
+                )
+            )
+        )
+    }
 }

src/test/kotlin/no/nav/k9/los/nyoppgavestyring/query/OppgavefilterUtviderTest.kt

@@ -7,6 +7,7 @@ import assertk.assertions.support.fail
 import no.nav.k9.los.domene.lager.oppgave.v2.equalsWithPrecision
 import no.nav.k9.los.nyoppgavestyring.FeltType
 import no.nav.k9.los.nyoppgavestyring.query.db.CombineOperator
+import no.nav.k9.los.nyoppgavestyring.query.db.EksternFeltverdiOperator
 import no.nav.k9.los.nyoppgavestyring.query.db.FeltverdiOperator
 import no.nav.k9.los.nyoppgavestyring.query.db.OppgavefilterUtvider
 import no.nav.k9.los.nyoppgavestyring.query.dto.query.CombineOppgavefilter
@@ -54,15 +55,37 @@ class OppgavefilterUtviderTest {
         assertThat(sisteDatoKombiner.hentFørsteMedOperator(FeltverdiOperator.LESS_THAN).verdi.first()).isEqualToDate(LocalDateTime.parse("2023-05-07T00:00:00"))
         assertThat(sisteDatoKombiner.hentFørsteMedOperator(FeltverdiOperator.GREATER_THAN).verdi.first()).isEqualToDate(LocalDateTime.parse("2023-05-07T23:59:59.999"))
     }
+
+    @Test
+    fun `Oppgavefiltre skal håndtere intervall-operator`() {
+        val oppgavefiltre = listOf(
+            FeltverdiOppgavefilter(null, FeltType.mottattDato.eksternId, EksternFeltverdiOperator.INTERVAL.name, listOf("2023-05-05", "2023-05-07"))
+        )
+
+        val combineFilter = OppgavefilterUtvider.utvid(oppgavefiltre).first() as CombineOppgavefilter
+        assertThat(combineFilter.combineOperator).isEqualTo(CombineOperator.AND.kode)
+
+        val (førsteDatoKombiner, sisteDatoKombiner) = combineFilter.filtere.map { it as FeltverdiOppgavefilter }.apply { first() to last() }
+        assertThat(førsteDatoKombiner.operator).isEqualTo(FeltverdiOperator.GREATER_THAN_OR_EQUALS.name)
+        assertThat(førsteDatoKombiner.verdi).containsOnlyDate(LocalDateTime.parse("2023-05-05T00:00"))
+
+        assertThat(sisteDatoKombiner.operator).isEqualTo(FeltverdiOperator.LESS_THAN_OR_EQUALS.name)
+        assertThat(sisteDatoKombiner.verdi).containsOnlyDate(LocalDateTime.parse("2023-05-07T23:59:59.999"))
+    }
 }
 
 
 internal fun CombineOppgavefilter.hentFørsteMedOperator(operator: FeltverdiOperator) = filtere.map { it as FeltverdiOppgavefilter }.hentFørsteMedOperator(operator)
 
 internal fun List<FeltverdiOppgavefilter>.hentFørsteMedOperator(operator: FeltverdiOperator) = first { it.operator == operator.name }
 
+internal fun Assert<List<Any?>>.containsOnlyDate(expected: LocalDateTime) = given { actual ->
+    actual.forEach {
+        if (!LocalDateTime.parse(it as String).equalsWithPrecision(expected, 10)) { fail(expected, it) }
+    }
+}
+
 internal fun Assert<Any?>.isEqualToDate(expected: LocalDateTime) = given { actual ->
     if (LocalDateTime.parse(actual as String).equalsWithPrecision(expected, 10)) return
     fail(expected, actual)
-}
-
+}

src/test/kotlin/no/nav/k9/los/nyoppgavestyring/query/db/EksternFeltverdiOperatorTest.kt

@@ -0,0 +1,15 @@
+package no.nav.k9.los.nyoppgavestyring.query.db
+
+import assertk.assertThat
+import assertk.assertions.containsAll
+import org.junit.jupiter.api.Test
+
+class EksternFeltverdiOperatorTest {
+
+    @Test
+    fun `Skal inneholde alle typene som finnes i den interne FeltVerdiOperator`() {
+        val feltverdiOperatorBruktEksternt = EksternFeltverdiOperator.entries.map { it.name }
+        val feltverdiOperatorBruktInternt = FeltverdiOperator.entries.map { it.name }
+        assertThat(feltverdiOperatorBruktEksternt).containsAll(*feltverdiOperatorBruktInternt.toTypedArray())
+    }
+}