Cast verdi til riktig db-datatype, og konverter param til riktig Kotl…

…in-klasse (#2733)

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/domeneadaptere/k9/tilbaketillos/TilbakeEventTilDtoMapper.kt

@@ -137,8 +137,7 @@ class TilbakeEventTilDtoMapper {
                 nøkkel = "førsteFeilutbetalingDato",
                 verdi = event.førsteFeilutbetaling ?: forrigeOppgave?.hentVerdi("førsteFeilutbetalingDato")
             ),
-
-            ).filterNotNull().toMutableList()
+        )
 
         private fun utledAutomatiskBehandletFlagg(
             event: BehandlingProsessEventTilbakeDto,

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/mottak/feltdefinisjon/Datatype.kt

@@ -9,11 +9,7 @@ enum class Datatype(val kode: String) {
 
     companion object {
         fun fraKode(kode: String): Datatype {
-            return try {
-                Datatype.valueOf(kode)
-            } catch (e: IllegalArgumentException ) {
-                STRING
-            }
+            return entries.first { it.kode == kode }
         }
     }
-}
+}

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

@@ -39,7 +39,7 @@ class OppgaveQueryRepository(
     @WithSpan
     fun query(tx: TransactionalSession, request: QueryRequest, now: LocalDateTime): List<AktivOppgaveId> {
         val felter = hentAlleFelterMedMer(tx, medKodeverk = false)
-            .associate { felt -> OmrådeOgKode(felt.oppgavefelt.område, felt.oppgavefelt.kode) to felt }
+            .associateBy { felt -> OmrådeOgKode(felt.oppgavefelt.område, felt.oppgavefelt.kode) }
 
         return query(tx, OppgaveQueryToSqlMapper.toSqlOppgaveQuery(request, felter, now))
     }
@@ -123,8 +123,8 @@ class OppgaveQueryRepository(
                         tolkes_som = row.string("tolkes_som"),
                         kokriterie = row.boolean("kokriterie"),
                         verdiforklaringerErUttømmende = kodeverk?.uttømmende ?: false,
-                        verdiforklaringer = kodeverk?.let { kodeverk ->
-                            kodeverk.verdier.map { kodeverkverdi ->
+                        verdiforklaringer = kodeverk?.let {
+                            it.verdier.map { kodeverkverdi ->
                                 Verdiforklaring(
                                     verdi = kodeverkverdi.verdi,
                                     visningsnavn = kodeverkverdi.visningsnavn,

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

@@ -1,7 +1,7 @@
 package no.nav.k9.los.nyoppgavestyring.query.db
 
-import no.nav.k9.los.nyoppgavestyring.kodeverk.EgenAnsatt
 import no.nav.k9.los.nyoppgavestyring.kodeverk.BeskyttelseType
+import no.nav.k9.los.nyoppgavestyring.kodeverk.EgenAnsatt
 import no.nav.k9.los.nyoppgavestyring.kodeverk.PersonBeskyttelseType
 import no.nav.k9.los.nyoppgavestyring.mottak.feltdefinisjon.Datatype
 import no.nav.k9.los.nyoppgavestyring.mottak.feltdefinisjon.Datatype.*
@@ -12,10 +12,6 @@ import no.nav.k9.los.spi.felter.OrderByInput
 import no.nav.k9.los.spi.felter.SqlMedParams
 import no.nav.k9.los.spi.felter.TransientFeltutleder
 import no.nav.k9.los.spi.felter.WhereInput
-import org.postgresql.util.PGInterval
-import java.math.BigDecimal
-import java.math.BigInteger
-import java.time.LocalDate
 import java.time.LocalDateTime
 
 class OppgaveQuerySqlBuilder(
@@ -182,68 +178,33 @@ class OppgaveQuerySqlBuilder(
                     INNER JOIN Oppgavefelt f ON (f.id = ov.oppgavefelt_id) 
                     INNER JOIN Feltdefinisjon fd ON (fd.id = f.feltdefinisjon_id) 
                     INNER JOIN Omrade fo ON (fo.id = fd.omrade_id)
-                    WHERE ov.oppgave_id = o.id
+                    WHERE CASE WHEN ov.oppgave_id = o.id
                       AND fo.ekstern_id = :feltOmrade$index
                       AND fd.ekstern_id = :feltkode$index
-                      AND 
+                      THEN 
             """.trimIndent()
 
         /*
          * Postgres støtter ikke betinget typekonvertering av queryparametere. Dette fordi
          * 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)"
-        val queryVerdiParam = castTilRiktigKotlintype(feltområde, feltkode, feltverdi)
-
-        query += ") "
+        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 queryVerdiParam
+            "feltverdi$index" to feltverdi
         ))
     }
 
     private fun databaseverdiMedCasting(feltområde: String, feltkode: String): String {
-        when (oppgavefelterKodeOgType[OmrådeOgKode(feltområde, feltkode)]) {
-            TIMESTAMP -> {
-                return "CAST(ov.verdi AS timestamp)"
-            }
-            DURATION -> {
-                return "CAST(ov.verdi AS interval)"
-            }
-            INTEGER -> {
-                return "CAST(ov.verdi AS integer)"
-            }
-            else -> {
-                return "ov.verdi"
-            }
-        }
-    }
-
-    private fun castTilRiktigKotlintype(feltområde: String, feltkode: String, feltverdi: Any): Any? {
-        when (oppgavefelterKodeOgType[OmrådeOgKode(feltområde, feltkode)]) {
-            TIMESTAMP -> {
-                return try {
-                    LocalDateTime.parse(feltverdi as String)
-                } catch (e: Exception) { null } ?: try {
-                    LocalDate.parse(feltverdi as String)
-                } catch (e: Exception) { null }
-            }
-            DURATION -> {
-                return try {
-                    PGInterval(feltverdi as String)
-                } catch (e: Exception) { null }
-            }
-            INTEGER -> {
-                return try {
-                    BigInteger(feltverdi as String)
-                } catch (e: Exception) { null }
-            }
-            else -> {
-                return feltverdi
-            }
+        return when (oppgavefelterKodeOgType[OmrådeOgKode(feltområde, feltkode)]) {
+            TIMESTAMP -> "CAST(ov.verdi AS timestamp without time zone)"
+            DURATION -> "CAST(ov.verdi AS interval)"
+            INTEGER -> "CAST(ov.verdi AS integer)"
+            BOOLEAN -> "CAST(ov.verdi AS boolean)"
+            else -> "ov.verdi"
         }
     }
 

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/dto/query/EnkelOrderFelt.kt

@@ -13,7 +13,7 @@ import com.fasterxml.jackson.annotation.JsonTypeName
     fieldVisibility = JsonAutoDetect.Visibility.ANY
 )
 @JsonTypeName("enkel")
-class EnkelOrderFelt(
+data class EnkelOrderFelt(
     val område: String?,
     val kode: String,
     val økende: Boolean

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/dto/query/Oppgavefilter.kt

@@ -17,6 +17,4 @@ import com.fasterxml.jackson.annotation.JsonTypeInfo
     setterVisibility = JsonAutoDetect.Visibility.NONE,
     fieldVisibility = JsonAutoDetect.Visibility.ANY
 )
-open class Oppgavefilter {
-
-}
+sealed class Oppgavefilter

src/main/kotlin/no/nav/k9/los/nyoppgavestyring/query/dto/query/OrderFelt.kt

@@ -15,4 +15,4 @@ import com.fasterxml.jackson.annotation.JsonTypeInfo
     setterVisibility = JsonAutoDetect.Visibility.NONE,
     fieldVisibility = JsonAutoDetect.Visibility.ANY
 )
-open class OrderFelt()
+sealed class OrderFelt()

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

@@ -11,7 +11,7 @@ object OppgaveQueryToSqlMapper {
         val query = OppgaveQuerySqlBuilder(felter, traverserFiltereOgFinnOppgavestatusfilter(request), now)
         val combineOperator = CombineOperator.AND
 
-        håndterFiltere(query, request.oppgaveQuery.filtere, combineOperator)
+        håndterFiltere(query, felter, OppgavefilterRens.rens(felter, request.oppgaveQuery.filtere), combineOperator)
         håndterOrder(query, request.oppgaveQuery.order)
         if (request.fjernReserverte) {
             query.utenReservasjoner()
@@ -26,14 +26,14 @@ object OppgaveQueryToSqlMapper {
         felter: Map<OmrådeOgKode, OppgavefeltMedMer>,
         now: LocalDateTime
     ): OppgaveQuerySqlBuilder {
-        val query = OppgaveQuerySqlBuilder(felter, traverserFiltereOgFinnOppgavestatusfilter(request), now)
+        val queryBuilder = OppgaveQuerySqlBuilder(felter, traverserFiltereOgFinnOppgavestatusfilter(request), now)
         val combineOperator = CombineOperator.AND
-        håndterFiltere(query, request.oppgaveQuery.filtere, combineOperator)
-        if (request.fjernReserverte) { query.utenReservasjoner() }
-        request.avgrensning?.let { query.medPaging(it.limit, it.offset) }
-        query.medAntallSomResultat()
+        håndterFiltere(queryBuilder, felter, OppgavefilterRens.rens(felter, request.oppgaveQuery.filtere), combineOperator)
+        if (request.fjernReserverte) { queryBuilder.utenReservasjoner() }
+        request.avgrensning?.let { queryBuilder.medPaging(it.limit, it.offset) }
+        queryBuilder.medAntallSomResultat()
 
-        return query
+        return queryBuilder
     }
 
     private fun traverserFiltereOgFinnOppgavestatusfilter(queryRequest: QueryRequest): List<Oppgavestatus> {
@@ -64,13 +64,14 @@ object OppgaveQueryToSqlMapper {
     }
 
     private fun håndterFiltere(
-        query: OppgaveQuerySqlBuilder,
+        queryBuilder: OppgaveQuerySqlBuilder,
+        felter:  Map<OmrådeOgKode, OppgavefeltMedMer>,
         filtere: List<Oppgavefilter>,
         combineOperator: CombineOperator
     ) {
-        for (filter in OppgavefilterUtvider.utvid(filtere)) {
+        for (filter in filtere) {
             when (filter) {
-                is FeltverdiOppgavefilter -> query.medFeltverdi(
+                is FeltverdiOppgavefilter -> queryBuilder.medFeltverdi(
                     combineOperator,
                     filter.område,
                     filter.kode,
@@ -80,12 +81,10 @@ object OppgaveQueryToSqlMapper {
 
                 is CombineOppgavefilter -> {
                     val newCombineOperator = CombineOperator.valueOf(filter.combineOperator)
-                    query.medBlokk(combineOperator, newCombineOperator.defaultValue) {
-                        håndterFiltere(query, filter.filtere, newCombineOperator)
+                    queryBuilder.medBlokk(combineOperator, newCombineOperator.defaultValue) {
+                        håndterFiltere(queryBuilder, felter, filter.filtere, newCombineOperator)
                     }
                 }
-
-                else -> throw IllegalStateException("Ukjent filter: " + filter::class.qualifiedName)
             }
         }
     }
@@ -94,7 +93,6 @@ object OppgaveQueryToSqlMapper {
         for (orderBy in orderBys) {
             when (orderBy) {
                 is EnkelOrderFelt -> query.medEnkelOrder(orderBy.område, orderBy.kode, orderBy.økende)
-                else -> throw IllegalStateException("Ukjent OrderFelt: " + orderBy::class.qualifiedName)
             }
         }
     }

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

@@ -0,0 +1,42 @@
+package no.nav.k9.los.nyoppgavestyring.query.mapping
+
+import no.nav.k9.los.nyoppgavestyring.mottak.feltdefinisjon.Datatype
+import no.nav.k9.los.nyoppgavestyring.query.db.OmrådeOgKode
+import no.nav.k9.los.nyoppgavestyring.query.db.OppgavefeltMedMer
+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
+import org.postgresql.util.PGInterval
+import java.math.BigInteger
+import java.time.LocalDateTime
+import kotlin.time.Duration
+
+object OppgavefilterDatatypeMapper {
+    fun map(felter: Map<OmrådeOgKode, OppgavefeltMedMer>, oppgavefiltere: List<Oppgavefilter>): List<Oppgavefilter> {
+        return oppgavefiltere.map { filter ->
+            when (filter) {
+                is FeltverdiOppgavefilter -> mapFeltverdiFilter(felter, filter)
+                is CombineOppgavefilter -> CombineOppgavefilter(
+                    combineOperator = filter.combineOperator, map(felter, filter.filtere)
+                )
+            }
+        }
+    }
+
+    private fun mapFeltverdiFilter(
+        felter: Map<OmrådeOgKode, OppgavefeltMedMer>,
+        filter: FeltverdiOppgavefilter
+    ): 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
+        }
+    }
+}