🚧 Generasjon har avslag

spesialist-felles/src/main/kotlin/no/nav/helse/HelseDao.kt

@@ -22,6 +22,11 @@ abstract class HelseDao(private val dataSource: DataSource) {
     fun <T> Query.single(mapping: (Row) -> T?) =
         sessionOf(dataSource, strict = true).use { session -> session.run(this.map { mapping(it) }.asSingle) }
 
+    fun <T> Query.single(
+        session: TransactionalSession,
+        mapping: (Row) -> T?,
+    ) = session.run(this.map { mapping(it) }.asSingle)
+
     fun <T> Query.list(mapping: (Row) -> T?) = sessionOf(dataSource).use { session -> session.run(this.map { mapping(it) }.asList) }
 
     fun <T> Query.list(

spesialist-modell/src/main/kotlin/no/nav/helse/modell/vedtak/Avslag.kt

@@ -8,6 +8,12 @@ class Avslag(
         vedtakBuilder.avslagData(type, begrunnelse)
     }
 
+    fun toDto() =
+        AvslagDto(
+            type = type.toDto(),
+            begrunnelse = begrunnelse,
+        )
+
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false
@@ -30,4 +36,11 @@ class Avslag(
 enum class Avslagstype {
     AVSLAG,
     DELVIS_AVSLAG,
+    ;
+
+    internal fun toDto() =
+        when (this) {
+            AVSLAG -> AvslagstypeDto.AVSLAG
+            DELVIS_AVSLAG -> AvslagstypeDto.DELVIS_AVSLAG
+        }
 }

spesialist-modell/src/main/kotlin/no/nav/helse/modell/vedtak/Sykepengevedtak.kt

@@ -171,6 +171,11 @@ data class SkjønnsfastsettingopplysningerDto(
 )
 
 data class AvslagDto(
-    val type: Avslagstype,
+    val type: AvslagstypeDto,
     val begrunnelse: String,
 )
+
+enum class AvslagstypeDto {
+    AVSLAG,
+    DELVIS_AVSLAG,
+}

spesialist-modell/src/main/kotlin/no/nav/helse/modell/vedtak/SykepengevedtakBuilder.kt

@@ -108,7 +108,14 @@ class SykepengevedtakBuilder {
         type: Avslagstype,
         begrunnelse: String,
     ) = apply {
-        this.avslag = AvslagDto(type, begrunnelse)
+        this.avslag =
+            AvslagDto(
+                when (type) {
+                    Avslagstype.AVSLAG -> AvslagstypeDto.AVSLAG
+                    Avslagstype.DELVIS_AVSLAG -> AvslagstypeDto.DELVIS_AVSLAG
+                },
+                begrunnelse,
+            )
     }
 
     fun build(): Sykepengevedtak {

spesialist-modell/src/test/kotlin/no/nav/helse/modell/vedtak/SykepengevedtakBuilderTest.kt

@@ -216,7 +216,7 @@ class SykepengevedtakBuilderTest {
                 utbetalingId = utbetalingId,
                 skjønnsfastsettingopplysninger = null,
                 tags = setOf("IngenNyArbeidsgiverperiode"),
-                avslag = AvslagDto(Avslagstype.DELVIS_AVSLAG, "En individuell begrunnelse for avslag"),
+                avslag = AvslagDto(AvslagstypeDto.DELVIS_AVSLAG, "En individuell begrunnelse for avslag"),
             ),
             utkast,
         )
@@ -292,7 +292,7 @@ class SykepengevedtakBuilderTest {
                     Skjønnsfastsettingsårsak.ANDRE_AVSNITT,
                 ),
                 tags = setOf("IngenNyArbeidsgiverperiode"),
-                avslag = AvslagDto(Avslagstype.AVSLAG, "En individuell begrunnelse for avslag"),
+                avslag = AvslagDto(AvslagstypeDto.AVSLAG, "En individuell begrunnelse for avslag"),
             ),
             utkast,
         )

spesialist-selve/src/main/kotlin/no/nav/helse/db/AvslagDao.kt

@@ -1,12 +1,14 @@
 package no.nav.helse.db
 
+import kotliquery.TransactionalSession
 import no.nav.helse.HelseDao
 import no.nav.helse.modell.vedtak.Avslag
+import no.nav.helse.modell.vedtak.AvslagDto
 import no.nav.helse.spesialist.api.graphql.mutation.Avslagsdata
 import java.util.UUID
 import javax.sql.DataSource
 
-class AvslagDao(private val dataSource: DataSource) : HelseDao(dataSource) {
+class AvslagDao(dataSource: DataSource) : HelseDao(dataSource) {
     private fun lagreBegrunnelse(
         avslagsdata: Avslagsdata,
         saksbehandlerOid: UUID,
@@ -99,6 +101,34 @@ class AvslagDao(private val dataSource: DataSource) : HelseDao(dataSource) {
         }
     }
 
+    internal fun TransactionalSession.finnAvslag(
+        vedtaksperiodeId: UUID,
+        generasjonId: Long,
+    ) = asSQL(
+        """
+        SELECT begrunnelse_ref FROM avslag 
+        WHERE vedtaksperiode_id = :vedtaksperiodeId 
+        AND generasjon_ref = :generasjonId 
+        AND invalidert = false 
+        ORDER BY opprettet DESC LIMIT 1
+        """.trimIndent(),
+        mapOf(
+            "vedtaksperiodeId" to vedtaksperiodeId,
+            "generasjonId" to generasjonId,
+        ),
+    ).single(this) {
+        it.longOrNull("begrunnelse_ref")?.let { begrunnelseRef ->
+            asSQL(
+                """
+                SELECT type, tekst FROM begrunnelse WHERE id = :begrunnelseRef
+                """.trimIndent(),
+                mapOf("begrunnelseRef" to begrunnelseRef),
+            ).single { avslag ->
+                AvslagDto(enumValueOf(avslag.string("type")), avslag.string("tekst"))
+            }
+        }
+    }
+
     internal fun finnAlleAvslag(
         vedtaksperiodeId: UUID,
         utbetalingId: UUID,

spesialist-selve/src/main/kotlin/no/nav/helse/mediator/VedtakFattetMelder.kt

@@ -2,7 +2,7 @@ package no.nav.helse.mediator
 
 import net.logstash.logback.argument.StructuredArguments.kv
 import no.nav.helse.modell.person.PersonObserver
-import no.nav.helse.modell.vedtak.Avslagstype
+import no.nav.helse.modell.vedtak.AvslagstypeDto
 import no.nav.helse.modell.vedtak.Sykepengegrunnlagsfakta.Infotrygd
 import no.nav.helse.modell.vedtak.Sykepengegrunnlagsfakta.Spleis
 import no.nav.helse.modell.vedtak.Sykepengevedtak
@@ -166,8 +166,8 @@ internal class VedtakFattetMelder(
                             mapOf(
                                 "type" to
                                     when (sykepengevedtak.avslag!!.type) {
-                                        Avslagstype.AVSLAG -> "Avslag"
-                                        Avslagstype.DELVIS_AVSLAG -> "DelvisInnvilgelse"
+                                        AvslagstypeDto.AVSLAG -> "Avslag"
+                                        AvslagstypeDto.DELVIS_AVSLAG -> "DelvisInnvilgelse"
                                     },
                                 "begrunnelse" to sykepengevedtak.avslag!!.begrunnelse,
                                 "perioder" to

spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Generasjon.kt

@@ -13,6 +13,7 @@ import no.nav.helse.modell.person.vedtaksperiode.Varsel.Companion.inneholderVars
 import no.nav.helse.modell.person.vedtaksperiode.Varsel.Companion.inneholderVarselOmNegativtBeløp
 import no.nav.helse.modell.person.vedtaksperiode.Varsel.Companion.inneholderVarselOmTilbakedatering
 import no.nav.helse.modell.person.vedtaksperiode.Varsel.Companion.inneholderVarselOmÅpenGosysOppgave
+import no.nav.helse.modell.vedtak.Avslag
 import no.nav.helse.modell.vedtak.SykepengevedtakBuilder
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
@@ -28,6 +29,7 @@ internal class Generasjon private constructor(
     private var periode: Periode,
     private var tilstand: Tilstand,
     private var tags: List<String>,
+    private val avslag: Avslag?,
     varsler: Set<Varsel>,
 ) {
     internal constructor(
@@ -39,15 +41,16 @@ internal class Generasjon private constructor(
         spleisBehandlingId: UUID? = null,
         utbetalingId: UUID? = null,
     ) : this(
-        id,
-        vedtaksperiodeId,
-        utbetalingId,
-        spleisBehandlingId,
-        skjæringstidspunkt,
-        Periode(fom, tom),
-        VidereBehandlingAvklares,
-        emptyList(),
-        emptySet(),
+        id = id,
+        vedtaksperiodeId = vedtaksperiodeId,
+        utbetalingId = utbetalingId,
+        spleisBehandlingId = spleisBehandlingId,
+        skjæringstidspunkt = skjæringstidspunkt,
+        periode = Periode(fom, tom),
+        tilstand = VidereBehandlingAvklares,
+        tags = emptyList(),
+        avslag = null,
+        varsler = emptySet(),
     )
 
     private val varsler: MutableList<Varsel> = varsler.toMutableList()
@@ -77,6 +80,7 @@ internal class Generasjon private constructor(
             tom = periode.tom(),
             tilstand = tilstand.toDto(),
             tags = tags,
+            avslag = avslag?.toDto(),
             varsler = varsler.map(Varsel::toDto),
         )
 
@@ -549,6 +553,7 @@ internal class Generasjon private constructor(
             tilstand: Tilstand,
             tags: List<String>,
             varsler: Set<Varsel>,
+            avslag: Avslag?,
         ) = Generasjon(
             id = id,
             vedtaksperiodeId = vedtaksperiodeId,
@@ -559,6 +564,7 @@ internal class Generasjon private constructor(
             tilstand = tilstand,
             tags = tags,
             varsler = varsler,
+            avslag = avslag,
         )
 
         internal fun List<Generasjon>.håndterNyttVarsel(

spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDao.kt

@@ -4,6 +4,7 @@ import kotliquery.Query
 import kotliquery.TransactionalSession
 import kotliquery.queryOf
 import kotliquery.sessionOf
+import no.nav.helse.db.AvslagDao
 import no.nav.helse.modell.person.vedtaksperiode.VarselDto
 import no.nav.helse.modell.person.vedtaksperiode.VarselStatusDto
 import org.intellij.lang.annotations.Language
@@ -13,6 +14,8 @@ import java.util.UUID
 import javax.sql.DataSource
 
 class GenerasjonDao(private val dataSource: DataSource) {
+    private val avslagDao = AvslagDao(dataSource)
+
     internal fun TransactionalSession.finnGenerasjoner(vedtaksperiodeId: UUID): List<GenerasjonDto> {
         @Language("PostgreSQL")
         val query = """
@@ -37,6 +40,10 @@ class GenerasjonDao(private val dataSource: DataSource) {
                     tilstand = enumValueOf(row.string("tilstand")),
                     tags = row.array<String>("tags").toList(),
                     varsler = finnVarsler(generasjonRef),
+                    avslag =
+                        with(avslagDao) {
+                            this@finnGenerasjoner.finnAvslag(vedtaksperiodeId, generasjonRef)
+                        },
                 )
             }.asList,
         )
@@ -163,6 +170,7 @@ class GenerasjonDao(private val dataSource: DataSource) {
                     tilstand = enumValueOf(row.string("tilstand")),
                     tags = row.array<String>("tags").toList(),
                     varsler = finnVarsler(generasjonRef),
+                    avslag = with(avslagDao) { this@finnGenerasjon.finnAvslag(vedtaksperiodeId, generasjonRef) },
                 )
             }.asSingle,
         )
@@ -204,12 +212,6 @@ class GenerasjonDao(private val dataSource: DataSource) {
         )
     }
 
-    internal fun finnSkjæringstidspunktFor(vedtaksperiodeId: UUID): LocalDate? {
-        return sessionOf(dataSource).use { session ->
-            session.run(finnSiste(vedtaksperiodeId).map { it.localDate("skjæringstidspunkt") }.asSingle)
-        }
-    }
-
     internal fun finnSisteGenerasjonIdFor(vedtaksperiodeId: UUID): Long? {
         return sessionOf(dataSource).use { session ->
             session.run(finnSiste(vedtaksperiodeId).map { it.long("id") }.asSingle)

spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonDto.kt

@@ -1,6 +1,7 @@
 package no.nav.helse.modell.vedtaksperiode
 
 import no.nav.helse.modell.person.vedtaksperiode.VarselDto
+import no.nav.helse.modell.vedtak.AvslagDto
 import java.time.LocalDate
 import java.util.UUID
 
@@ -15,6 +16,7 @@ data class GenerasjonDto(
     val tilstand: TilstandDto,
     val tags: List<String>,
     val varsler: List<VarselDto>,
+    val avslag: AvslagDto?,
 )
 
 enum class TilstandDto {

spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/GenerasjonRepository.kt

@@ -1,40 +1,21 @@
 package no.nav.helse.modell.vedtaksperiode
 
 import kotliquery.TransactionalSession
-import kotliquery.sessionOf
 import no.nav.helse.modell.VedtakDao
 import no.nav.helse.modell.person.vedtaksperiode.VarselDto
 import org.slf4j.LoggerFactory
-import java.time.LocalDate
 import java.util.UUID
 import javax.sql.DataSource
 
-internal class GenerasjonRepository(private val dataSource: DataSource) {
-    private val dao = GenerasjonDao(dataSource)
+internal class GenerasjonRepository(dataSource: DataSource) {
+    private val generasjonDao = GenerasjonDao(dataSource)
     private val vedtakDao = VedtakDao(dataSource)
     private var hentedeGenerasjoner: List<GenerasjonDto> = emptyList()
 
     private val sikkerLogger = LoggerFactory.getLogger("tjenestekall")
 
-    internal fun brukVedtaksperiode(
-        fødselsnummer: String,
-        vedtaksperiodeId: UUID,
-        block: (vedtaksperiode: Vedtaksperiode) -> Unit,
-    ) {
-        sessionOf(dataSource).use { session ->
-            session.transaction { tx ->
-                val vedtaksperiode =
-                    tx.finnVedtaksperiode(vedtaksperiodeId).let {
-                        Vedtaksperiode.gjenopprett(it.organisasjonsnummer, it.vedtaksperiodeId, it.forkastet, it.generasjoner)
-                    }
-                block(vedtaksperiode)
-                tx.lagreVedtaksperiode(fødselsnummer, vedtaksperiode.toDto())
-            }
-        }
-    }
-
     internal fun TransactionalSession.finnVedtaksperioder(fødselsnummer: String): List<VedtaksperiodeDto> {
-        return with(dao) {
+        return with(generasjonDao) {
             finnVedtaksperiodeIderFor(fødselsnummer).map { finnVedtaksperiode(it) }
         }
     }
@@ -55,7 +36,7 @@ internal class GenerasjonRepository(private val dataSource: DataSource) {
     }
 
     private fun TransactionalSession.finnGenerasjoner(vedtaksperiodeId: UUID): List<GenerasjonDto> {
-        return with(dao) {
+        return with(generasjonDao) {
             finnGenerasjoner(vedtaksperiodeId).also { hentedeGenerasjoner = it }
         }
     }
@@ -67,7 +48,7 @@ internal class GenerasjonRepository(private val dataSource: DataSource) {
         with(vedtakDao) {
             lagreVedtaksperiode(fødselsnummer, vedtaksperiode)
         }
-        with(dao) {
+        with(generasjonDao) {
             loggDiffMellomHentetOgSkalLagres(vedtaksperiode)
             hentedeGenerasjoner = emptyList()
             vedtaksperiode.generasjoner.forEach { generasjonDto ->
@@ -129,10 +110,5 @@ internal class GenerasjonRepository(private val dataSource: DataSource) {
         appendLine("  skj.tidspkt: ${hentet.skjæringstidspunkt} - ${skalLagres.skjæringstidspunkt}")
     }
 
-    internal fun skjæringstidspunktFor(vedtaksperiodeId: UUID): LocalDate {
-        return dao.finnSkjæringstidspunktFor(vedtaksperiodeId)
-            ?: throw IllegalStateException("Forventer å finne skjæringstidspunkt for vedtaksperiodeId=$vedtaksperiodeId")
-    }
-
-    internal fun førsteKjenteDag(fødselsnummer: String) = dao.førsteKjenteDag(fødselsnummer)
+    internal fun førsteKjenteDag(fødselsnummer: String) = generasjonDao.førsteKjenteDag(fødselsnummer)
 }

spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Vedtaksperiode.kt

@@ -5,6 +5,9 @@ import no.nav.helse.modell.person.Person
 import no.nav.helse.modell.person.vedtaksperiode.Varsel
 import no.nav.helse.modell.person.vedtaksperiode.VarselStatusDto
 import no.nav.helse.modell.utbetaling.UtbetalingEndret
+import no.nav.helse.modell.vedtak.Avslag
+import no.nav.helse.modell.vedtak.Avslagstype
+import no.nav.helse.modell.vedtak.AvslagstypeDto
 import no.nav.helse.modell.vedtak.AvsluttetUtenVedtak
 import no.nav.helse.modell.vedtak.SykepengevedtakBuilder
 import no.nav.helse.modell.vedtaksperiode.Generasjon.Companion.finnGenerasjonForSpleisBehandling
@@ -205,6 +208,17 @@ internal class Vedtaksperiode private constructor(
                         TilstandDto.KlarTilBehandling -> Generasjon.KlarTilBehandling
                     },
                 tags = tags.toList(),
+                avslag =
+                    avslag?.let {
+                        Avslag(
+                            type =
+                                when (it.type) {
+                                    AvslagstypeDto.AVSLAG -> Avslagstype.AVSLAG
+                                    AvslagstypeDto.DELVIS_AVSLAG -> Avslagstype.DELVIS_AVSLAG
+                                },
+                            begrunnelse = it.begrunnelse,
+                        )
+                    },
                 varsler =
                     varsler.map { varselDto ->
                         Varsel(