Begynt på å tillatte liste-betingelser

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

@@ -74,77 +74,85 @@ class OppgaveQuerySqlBuilder(
         return felter[OmrådeOgKode(feltområde, feltkode)]?.transientFeltutleder
     }
 
-    fun medFeltverdi(combineOperator: CombineOperator, feltområde: String?, feltkode: String, operator: FeltverdiOperator, feltverdi: Any?) {
+    fun medFeltverdi(combineOperator: CombineOperator, feltområde: String?, feltkode: String, operator: FeltverdiOperator, feltverdiListe: List<Any?>) {
         hentTransientFeltutleder(feltområde, feltkode)?.let {
             val sqlMedParams = sikreUnikeParams(
-                it.where(WhereInput(now, feltområde!!, feltkode, operator, feltverdi))
+                it.where(WhereInput(now, feltområde!!, feltkode, operator, feltverdiListe))
             )
             query += "${combineOperator.sql} " + sqlMedParams.query
             queryParams.putAll(sqlMedParams.queryParams)
             return
         }
 
         if (feltområde != null) {
-            if (feltverdi == null) {
-                utenOppgavefelt(combineOperator, feltområde, feltkode, operator)
-            } else {
-                medOppgavefelt(combineOperator, feltområde, feltkode, operator, feltverdi)
-            }
+//            if (feltverdi == null) {
+//                utenOppgavefelt(combineOperator, feltområde, feltkode, operator)
+//            } else {
+                medOppgavefelt(
+                    combineOperator = combineOperator,
+                    feltområde = feltområde,
+                    feltkode = feltkode,
+                    operator = operator,
+                    feltverdi = feltverdiListe
+                )
+//            }
             return
         }
 
-        val index = queryParams.size + orderByParams.size
-        when (feltkode) {
-            "oppgavestatus" -> {
-                query += "${combineOperator.sql} o.status ${operator.sql} (cast(:oppgavestatus$index as oppgavestatus)) "
-                queryParams["oppgavestatus$index"] = feltverdi
-            }
+        feltverdiListe.forEach { feltverdi ->
+            val index = queryParams.size + orderByParams.size
+            when (feltkode) {
+                "oppgavestatus" -> {
+                    query += "${combineOperator.sql} o.status ${operator.sql} (cast(:oppgavestatus$index as oppgavestatus)) "
+                    queryParams["oppgavestatus$index"] = feltverdi
+                }
 
-            "kildeområde" -> {
-                query += "${combineOperator.sql} o.kildeomrade ${operator.sql} (:kildeomrade$index) "
-                queryParams["kildeomrade$index"] = feltverdi
-            }
+                "kildeområde" -> {
+                    query += "${combineOperator.sql} o.kildeomrade ${operator.sql} (:kildeomrade$index) "
+                    queryParams["kildeomrade$index"] = feltverdi
+                }
 
-            "oppgavetype" -> {
-                query += "${combineOperator.sql} ot.ekstern_id ${operator.sql} (:oppgavetype$index) "
-                queryParams["oppgavetype$index"] = feltverdi
-            }
+                "oppgavetype" -> {
+                    query += "${combineOperator.sql} ot.ekstern_id ${operator.sql} (:oppgavetype$index) "
+                    queryParams["oppgavetype$index"] = feltverdi
+                }
 
-            "oppgaveområde" -> {
-                query += "${combineOperator.sql} oppgave_omrade.ekstern_id ${operator.sql} (:oppgave_omrade$index) "
-                queryParams["oppgave_omrade$index"] = feltverdi
-            }
+                "oppgaveområde" -> {
+                    query += "${combineOperator.sql} oppgave_omrade.ekstern_id ${operator.sql} (:oppgave_omrade$index) "
+                    queryParams["oppgave_omrade$index"] = feltverdi
+                }
 
-            //deprecated - for removal - bruk "personbeskyttelse" istedet
-            "beskyttelse" -> {
-                when (feltverdi) {
-                    BeskyttelseType.KODE7.kode -> query += "${combineOperator.sql} opc.kode7 is not false "
-                    else -> {
-                        query += "${combineOperator.sql} opc.kode6 is not true AND opc.kode7 is not true "
+                //deprecated - for removal - bruk "personbeskyttelse" istedet
+                "beskyttelse" -> {
+                    when (feltverdi) {
+                        BeskyttelseType.KODE7.kode -> query += "${combineOperator.sql} opc.kode7 is not false "
+                        else -> {
+                            query += "${combineOperator.sql} opc.kode6 is not true AND opc.kode7 is not true "
+                        }
                     }
                 }
-            }
 
-            //deprecated - for removal - bruk "personbeskyttelse" istedet
-            "egenAnsatt" -> {
-                query += when (feltverdi) {
-                    EgenAnsatt.JA.kode -> "${combineOperator.sql} opc.egen_ansatt is not false "
-                    EgenAnsatt.NEI.kode -> "${combineOperator.sql} opc.egen_ansatt is not true "
-                    else -> throw IllegalStateException("Ukjent feltkode: $feltkode")
+                //deprecated - for removal - bruk "personbeskyttelse" istedet
+                "egenAnsatt" -> {
+                    query += when (feltverdi) {
+                        EgenAnsatt.JA.kode -> "${combineOperator.sql} opc.egen_ansatt is not false "
+                        EgenAnsatt.NEI.kode -> "${combineOperator.sql} opc.egen_ansatt is not true "
+                        else -> throw IllegalStateException("Ukjent feltkode: $feltkode")
+                    }
                 }
-            }
 
-            "personbeskyttelse" -> {
-                query += when (feltverdi) {
-                    //Dette er ikke tilgangskontroll, men tilordning av oppgaver til køer. Tilgangskontroll skjer når saksbehandlere plukker/ser på hva som er i køene.
-                    //Negeringer i uttrykkene er for å slippe gjennom treff mot null (skjer om PEP_CACHE ikke er populert/er utdatert).
-                    PersonBeskyttelseType.KODE6.kode -> "${combineOperator.sql} opc.kode6 is not false "
-                    PersonBeskyttelseType.UTEN_KODE6.kode -> "${combineOperator.sql} opc.kode6 is not true "
-                    PersonBeskyttelseType.KODE7_ELLER_EGEN_ANSATT.kode -> "${combineOperator.sql} (opc.kode6 is not true AND (opc.kode7 is not false OR opc.egen_ansatt is not false)) "
-                    PersonBeskyttelseType.UGRADERT.kode -> "${combineOperator.sql} (opc.kode6 is not true AND opc.kode7 is not true AND opc.egen_ansatt is not true )"
-                    else -> throw IllegalStateException("Ukjent feltkode: $feltkode")
+                "personbeskyttelse" -> {
+                    query += when (feltverdi) {
+                        //Dette er ikke tilgangskontroll, men tilordning av oppgaver til køer. Tilgangskontroll skjer når saksbehandlere plukker/ser på hva som er i køene.
+                        //Negeringer i uttrykkene er for å slippe gjennom treff mot null (skjer om PEP_CACHE ikke er populert/er utdatert).
+                        PersonBeskyttelseType.KODE6.kode -> "${combineOperator.sql} opc.kode6 is not false "
+                        PersonBeskyttelseType.UTEN_KODE6.kode -> "${combineOperator.sql} opc.kode6 is not true "
+                        PersonBeskyttelseType.KODE7_ELLER_EGEN_ANSATT.kode -> "${combineOperator.sql} (opc.kode6 is not true AND (opc.kode7 is not false OR opc.egen_ansatt is not false)) "
+                        PersonBeskyttelseType.UGRADERT.kode -> "${combineOperator.sql} (opc.kode6 is not true AND opc.kode7 is not true AND opc.egen_ansatt is not true )"
+                        else -> throw IllegalStateException("Ukjent feltkode: $feltkode")
+                    }
                 }
-            }
+        }
         }
     }
 
@@ -168,7 +176,7 @@ class OppgaveQuerySqlBuilder(
         query += ") "
     }
 
-    private fun medOppgavefelt(combineOperator: CombineOperator, feltområde: String, feltkode: String, operator: FeltverdiOperator, feltverdi: Any) {
+    private fun medOppgavefelt(combineOperator: CombineOperator, feltområde: String, feltkode: String, operator: FeltverdiOperator, feltverdi: List<Any?>) {
         val index = queryParams.size + orderByParams.size
 
         query += """
@@ -189,13 +197,18 @@ class OppgaveQuerySqlBuilder(
          * typekonverteringen blir gjort ved opprettelse av spørring og at feilende
          * typekonvertering gjør at spørringen feiler.
          */
-        query += "${databaseverdiMedCasting(feltområde, feltkode)} ${operator.negasjonAv?.sql ?: operator.sql} (:feltverdi$index) END) "
 
-        queryParams.putAll(mapOf(
-            "feltOmrade$index" to feltområde,
-            "feltkode$index" to feltkode,
-            "feltverdi$index" to feltverdi
-        ))
+        val feltverdiParametre = feltverdi.mapIndexed { i, verdi -> "feltverdi" + (index + i) to verdi }
+
+        // inneholder f.eks. (:feltverdi0, :feltverdi1, :feltverdi2)
+        val verdiParametre = feltverdiParametre.joinToString(
+            ", "
+        ) { (parameter) -> ":$parameter" }
+        query += "${databaseverdiMedCasting(feltområde, feltkode)} ${operator.negasjonAv?.sql ?: operator.sql} ($verdiParametre) END) "
+
+        queryParams["feltOmrade$index"] = feltområde
+        queryParams["feltkode$index"] = feltkode
+        queryParams.putAll(feltverdiParametre)
     }
 
     private fun databaseverdiMedCasting(feltområde: String, feltkode: String): String {

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/OppgaveQueryToSqlMapper.kt

@@ -72,11 +72,11 @@ object OppgaveQueryToSqlMapper {
         for (filter in filtere) {
             when (filter) {
                 is FeltverdiOppgavefilter -> queryBuilder.medFeltverdi(
-                    combineOperator,
-                    filter.område,
-                    filter.kode,
-                    FeltverdiOperator.valueOf(filter.operator),
-                    filter.verdi.first()
+                    combineOperator = combineOperator,
+                    feltområde = filter.område,
+                    feltkode = filter.kode,
+                    operator = FeltverdiOperator.valueOf(filter.operator),
+                    feltverdiListe = filter.verdi
                 )
 
                 is CombineOppgavefilter -> {

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/OppgavefilterDatatypeMapper.kt

@@ -29,14 +29,19 @@ object OppgavefilterDatatypeMapper {
     ): FeltverdiOppgavefilter {
         val datatype = felter[OmrådeOgKode(filter.område, filter.kode)]?.oppgavefelt?.tolkes_som
             ?.let { Datatype.fraKode(it) }
-        val verdi = filter.verdi[0]
-        if (verdi == null || verdi !is String) return filter // er enten null eller har blitt konvertert tidligere
-        return when (datatype) {
-            Datatype.INTEGER -> filter.copy(verdi = listOf(verdi.toBigInteger()))
-            Datatype.DURATION -> filter.copy(verdi = listOf(PGInterval(verdi)))
-            Datatype.TIMESTAMP -> filter.copy(verdi = listOf(LocalDateTime.parse(verdi)))
-            Datatype.BOOLEAN -> filter.copy(verdi = listOf(verdi.toBoolean()))
-            else -> filter
+        val verdier = filter.verdi.map { verdi ->
+            if (verdi == null || verdi !is String) {
+                verdi // er enten null eller har blitt konvertert tidligere
+            } else {
+                when (datatype) {
+                    Datatype.INTEGER -> verdi.toBigInteger()
+                    Datatype.DURATION -> PGInterval(verdi)
+                    Datatype.TIMESTAMP -> LocalDateTime.parse(verdi)
+                    Datatype.BOOLEAN -> verdi.toBoolean()
+                    else -> verdi
+                }
+            }
         }
+        return filter.copy(verdi = verdier)
     }
 }

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/OppgavefilterListeEliminerer.kt → src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/OppgavefilterFlerverdiEliminerer.kt

@@ -4,7 +4,7 @@ import no.nav.k9.los.nyoppgavestyring.query.dto.query.CombineOppgavefilter
 import no.nav.k9.los.nyoppgavestyring.query.dto.query.FeltverdiOppgavefilter
 import no.nav.k9.los.nyoppgavestyring.query.dto.query.Oppgavefilter
 
-object OppgavefilterListeEliminerer {
+object OppgavefilterFlerverdiEliminerer {
     fun eliminer(oppgavefiltere: List<Oppgavefilter>): List<Oppgavefilter> {
         return oppgavefiltere.map { filter ->
             when (filter) {
@@ -18,27 +18,18 @@ object OppgavefilterListeEliminerer {
     }
 
     private fun map(filter: FeltverdiOppgavefilter): Oppgavefilter {
-        if (filter.verdi.size <= 1) {
+        if (filter.verdi.size <= 1 || filter.operator == EksternFeltverdiOperator.IN.name || filter.operator == EksternFeltverdiOperator.NOT_IN.name) {
             return filter
         }
 
-        val operator = EksternFeltverdiOperator.valueOf(filter.operator)
-        if (operator == EksternFeltverdiOperator.INTERVAL) {
+        if (filter.operator == EksternFeltverdiOperator.INTERVAL.name) {
             return lagInterval(filter)
         }
 
-        val (combineOperator, feltverdiOperator) = 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")
-        }
-
         return CombineOppgavefilter(
-            combineOperator = combineOperator.kode,
+            combineOperator = CombineOperator.AND.name,
             filtere = filter.verdi.map { verdi ->
                 filter.copy(
-                    operator = feltverdiOperator.name,
                     verdi = listOf(verdi)
                 )
             }

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/OppgavefilterLocalDateSpesialhåndterer.kt

@@ -28,6 +28,16 @@ object OppgavefilterLocalDateSpesialhåndterer {
     }
 
     private fun mapFeltverdiFilter(filter: FeltverdiOppgavefilter): Oppgavefilter {
+        // TODO: Rydd opp og forenkle litt
+        if (filter.verdi.size > 1) {
+            return filter.copy(verdi = filter.verdi.map {
+                try {
+                    if (it is String) LocalDate.parse(it).atTime(LocalTime.MIN) else it
+                } catch (ex: DateTimeParseException) {
+                    it
+                }
+            })
+        }
         val verdi = filter.verdi[0]
         if (verdi !is String) {
             return filter

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/OppgavefilterRens.kt

@@ -8,7 +8,7 @@ object OppgavefilterRens {
     fun rens(felter:  Map<OmrådeOgKode, OppgavefeltMedMer>, oppgavefiltere: List<Oppgavefilter>): List<Oppgavefilter> {
         return oppgavefiltere
             .let { OppgavefilterUtenBetingelserFjerner.fjern(it)} // alle filtre har nå minst én verdi (kan være null)
-            .let { OppgavefilterListeEliminerer.eliminer(it) } // alle filtre har nå kun én verdi, og mengdeoperatorer er borte
+            .let { OppgavefilterFlerverdiEliminerer.eliminer(it) } // alle filtre har nå kun én verdi, og mengdeoperatorer er borte
             .let { OppgavefilterLocalDateSpesialhåndterer.spesialhåndter(it) } // dersom verdien lar seg parse til LocalDate, tilpass filtrene
             .let { OppgavefilterDatatypeMapper.map(felter, it) } // konverter filterverdiene til deres rette datatype
     }

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/transientfeltutleder/K9BeslutterTransientFeltutleder.kt

@@ -14,7 +14,7 @@ class K9BeslutterTransientFeltutleder: TransientFeltutleder{
     }
 
     override fun where(input: WhereInput): SqlMedParams {
-        val prefix: String = if (input.feltverdi as Boolean) "" else "NOT"
+        val prefix: String = if (input.feltverdi[0] as Boolean) "" else "NOT"
         val query = """
                 $prefix EXISTS (
                     SELECT 1

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/mapping/transientfeltutleder/LøpendeDurationTransientFeltutleder.kt

@@ -162,7 +162,7 @@ abstract class LøpendeDurationTransientFeltutleder(
                 ${sumLøpendeDuration.query} ${input.operator.sql} (:inputVerdi)
             """.trimIndent()
 
-        val inputVerdi = input.feltverdi as PGInterval
+        val inputVerdi = input.feltverdi[0] as PGInterval
 
         val params = mapOf("inputVerdi" to inputVerdi)
         return SqlMedParams(query, (sumLøpendeDuration.queryParams + params))

src/main/kotlin/no/nav/k9/los/spi/felter/TransientFeltutleder.kt

@@ -34,7 +34,7 @@ data class WhereInput(
     val feltområde: String,
     val feltkode: String,
     val operator: FeltverdiOperator, // TODO: Egen eksponert enum her.
-    val feltverdi: Any?
+    val feltverdi: List<Any?>
 )
 
 data class OrderByInput(

src/test/kotlin/no/nav/k9/los/nyoppgavestyring/query/db/OppgavefilterListeEliminererTest.kt → src/test/kotlin/no/nav/k9/los/nyoppgavestyring/query/db/OppgavefilterFlerverdiEliminererTest.kt

@@ -3,21 +3,21 @@ package no.nav.k9.los.nyoppgavestyring.query.db
 import assertk.assertThat
 import assertk.assertions.containsExactly
 import assertk.assertions.isEqualTo
-import no.nav.k9.los.nyoppgavestyring.query.mapping.OppgavefilterListeEliminerer
+import no.nav.k9.los.nyoppgavestyring.query.mapping.OppgavefilterFlerverdiEliminerer
 import no.nav.k9.los.nyoppgavestyring.query.dto.query.CombineOppgavefilter
 import no.nav.k9.los.nyoppgavestyring.query.dto.query.FeltverdiOppgavefilter
 import no.nav.k9.los.nyoppgavestyring.query.mapping.CombineOperator
 import no.nav.k9.los.nyoppgavestyring.query.mapping.FeltverdiOperator
 import org.junit.jupiter.api.Test
 
-class OppgavefilterListeEliminererTest {
+class OppgavefilterFlerverdiEliminererTest {
 
     @Test
     fun `Flere verdier med 'IN' skal endres til CombineOperator-OR med enverdi-filtre med EQUALS`() {
         val oppgavefiltre = listOf(
             FeltverdiOppgavefilter(null, "oppgavestatus", FeltverdiOperator.IN.name, listOf("OPPR", "AVSLU"))
         )
-        assertThat(OppgavefilterListeEliminerer.eliminer(oppgavefiltre).first()).isEqualTo(
+        assertThat(OppgavefilterFlerverdiEliminerer.eliminer(oppgavefiltre).first()).isEqualTo(
             CombineOppgavefilter(
                 CombineOperator.OR.kode, filtere = listOf(
                 FeltverdiOppgavefilter(null, "oppgavestatus", FeltverdiOperator.EQUALS.name, listOf("OPPR")),
@@ -31,7 +31,7 @@ class OppgavefilterListeEliminererTest {
         val oppgavefiltre = listOf(
             FeltverdiOppgavefilter(null, "aksjonspunkt", FeltverdiOperator.EQUALS.name, listOf("5053", "5016"))
         )
-        val resultat = OppgavefilterListeEliminerer.eliminer(oppgavefiltre)
+        val resultat = OppgavefilterFlerverdiEliminerer.eliminer(oppgavefiltre)
         assertThat(resultat).containsExactly(
             CombineOppgavefilter(
                 CombineOperator.AND.kode, filtere = listOf(
@@ -46,7 +46,7 @@ class OppgavefilterListeEliminererTest {
         val oppgavefiltre = listOf(
             FeltverdiOppgavefilter(null, "oppgavestatus", FeltverdiOperator.NOT_IN.name, listOf("OPPR", "AVSLU"))
         )
-        assertThat(OppgavefilterListeEliminerer.eliminer(oppgavefiltre).first()).isEqualTo(
+        assertThat(OppgavefilterFlerverdiEliminerer.eliminer(oppgavefiltre).first()).isEqualTo(
             CombineOppgavefilter(
                 CombineOperator.AND.kode, filtere = listOf(
                 FeltverdiOppgavefilter(null, "oppgavestatus", FeltverdiOperator.NOT_EQUALS.name, listOf("OPPR")),
@@ -65,7 +65,7 @@ class OppgavefilterListeEliminererTest {
             ))
         )
 
-        assertThat(OppgavefilterListeEliminerer.eliminer(oppgavefiltre).first()).isEqualTo(
+        assertThat(OppgavefilterFlerverdiEliminerer.eliminer(oppgavefiltre).first()).isEqualTo(
             CombineOppgavefilter(
                 CombineOperator.OR.kode, filtere = listOf(
                 CombineOppgavefilter(

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

@@ -110,7 +110,7 @@ class OppgaveQueryToSqlMapperTest {
 
         val sql = byggSql(sqlBuilder)
         assertThat(sqlBuilder.getQuery()).contains(sqlBuilder.getParams().keys)
-        assertThat(sqlBuilder.getParams()).hasSize(8 * 3) // totalt 8 betingelser, hver av de har parameter for feltkode, område og verdi
+        assertThat(sqlBuilder.getParams()).hasSize(16) // totalt x betingelser, hver av de har parameter for feltkode, område og verdi
     }
 
     private fun byggSql(sqlBuilder: OppgaveQuerySqlBuilder): String {