♻️ Oppgave knyttes til behandlingId

spesialist-felles/src/main/resources/db/migration/V540__oppgave_med_behandling_id.sql

@@ -0,0 +1,6 @@
+ALTER TABLE oppgave ADD COLUMN behandling_id UUID;
+CREATE INDEX ON oppgave(behandling_id);
+
+UPDATE oppgave o SET behandling_id = svg.spleis_behandling_id
+    FROM selve_vedtaksperiode_generasjon svg WHERE svg.unik_id = o.generasjon_ref
+AND o.status IN ('AvventerSaksbehandler'::oppgavestatus, 'AvventerSystem'::oppgavestatus);

spesialist-modell/src/main/kotlin/no/nav/helse/modell/oppgave/Oppgave.kt

@@ -28,6 +28,7 @@ class Oppgave private constructor(
     private val id: Long,
     private var tilstand: Tilstand,
     private val vedtaksperiodeId: UUID,
+    private val behandlingId: UUID,
     private val utbetalingId: UUID,
     private val hendelseId: UUID,
     private val kanAvvises: Boolean,
@@ -330,6 +331,7 @@ class Oppgave private constructor(
         fun nyOppgave(
             id: Long,
             vedtaksperiodeId: UUID,
+            behandlingId: UUID,
             utbetalingId: UUID,
             hendelseId: UUID,
             kanAvvises: Boolean,
@@ -340,6 +342,7 @@ class Oppgave private constructor(
                 id = id,
                 tilstand = AvventerSaksbehandler,
                 vedtaksperiodeId = vedtaksperiodeId,
+                behandlingId = behandlingId,
                 utbetalingId = utbetalingId,
                 hendelseId = hendelseId,
                 kanAvvises = kanAvvises,
@@ -359,6 +362,7 @@ class Oppgave private constructor(
                         Invalidert -> OppgaveDto.TilstandDto.Invalidert
                     },
                 vedtaksperiodeId = vedtaksperiodeId,
+                behandlingId = behandlingId,
                 utbetalingId = utbetalingId,
                 hendelseId = hendelseId,
                 kanAvvises = kanAvvises,
@@ -379,6 +383,7 @@ class Oppgave private constructor(
                         OppgaveDto.TilstandDto.Ferdigstilt -> Ferdigstilt
                         OppgaveDto.TilstandDto.Invalidert -> Invalidert
                     },
+                behandlingId = behandlingId,
                 vedtaksperiodeId = vedtaksperiodeId,
                 utbetalingId = utbetalingId,
                 hendelseId = hendelseId,

spesialist-modell/src/main/kotlin/no/nav/helse/modell/oppgave/OppgaveDto.kt

@@ -8,6 +8,7 @@ data class OppgaveDto(
     val id: Long,
     val tilstand: TilstandDto,
     val vedtaksperiodeId: UUID,
+    val behandlingId: UUID,
     val utbetalingId: UUID,
     val hendelseId: UUID,
     val kanAvvises: Boolean,

spesialist-modell/src/test/kotlin/no/nav/helse/modell/oppgave/OppgaveTest.kt

@@ -39,6 +39,7 @@ internal class OppgaveTest {
     private companion object {
         private val OPPGAVETYPE = SØKNAD
         private val VEDTAKSPERIODE_ID = UUID.randomUUID()
+        private val BEHANDLING_ID = UUID.randomUUID()
         private val UTBETALING_ID = UUID.randomUUID()
         private const val SAKSBEHANDLER_IDENT = "Z999999"
         private const val SAKSBEHANDLER_EPOST = "[email protected]"
@@ -573,6 +574,7 @@ internal class OppgaveTest {
                 id = nextLong(),
                 tilstand = tilstand,
                 vedtaksperiodeId = vedtaksperiodeId,
+                behandlingId = UUID.randomUUID(),
                 utbetalingId = utbetalingId,
                 hendelseId = UUID.randomUUID(),
                 kanAvvises = true,
@@ -599,21 +601,22 @@ internal class OppgaveTest {
     fun equals() {
         val gjenopptattOppgave =
             Oppgave.nyOppgave(
-                1L,
-                VEDTAKSPERIODE_ID,
-                UTBETALING_ID,
-                UUID.randomUUID(),
-                true,
-                setOf(OPPGAVETYPE),
+                id = 1L,
+                vedtaksperiodeId = VEDTAKSPERIODE_ID,
+                behandlingId = BEHANDLING_ID,
+                utbetalingId = UTBETALING_ID,
+                hendelseId = UUID.randomUUID(),
+                kanAvvises = true,
+                egenskaper = setOf(OPPGAVETYPE),
             )
         val oppgave1 =
-            Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD))
+            Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, BEHANDLING_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD))
         val oppgave2 =
-            Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD))
+            Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, BEHANDLING_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD))
         val oppgave3 =
-            Oppgave.nyOppgave(OPPGAVE_ID, UUID.randomUUID(), UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD))
+            Oppgave.nyOppgave(OPPGAVE_ID, UUID.randomUUID(), BEHANDLING_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(SØKNAD))
         val oppgave4 =
-            Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(STIKKPRØVE))
+            Oppgave.nyOppgave(OPPGAVE_ID, VEDTAKSPERIODE_ID, BEHANDLING_ID, UTBETALING_ID, UUID.randomUUID(), true, setOf(STIKKPRØVE))
         assertEquals(oppgave1, oppgave2)
         assertEquals(oppgave1.hashCode(), oppgave2.hashCode())
         assertNotEquals(oppgave1, oppgave3)
@@ -638,13 +641,14 @@ internal class OppgaveTest {
     ): Oppgave {
         val totrinnsvurdering = if (medTotrinnsvurdering) totrinnsvurdering() else null
         return Oppgave.nyOppgave(
-            OPPGAVE_ID,
-            VEDTAKSPERIODE_ID,
-            UTBETALING_ID,
-            UUID.randomUUID(),
-            true,
-            egenskaper.toSet(),
-            totrinnsvurdering,
+            id = OPPGAVE_ID,
+            vedtaksperiodeId = VEDTAKSPERIODE_ID,
+            behandlingId = UTBETALING_ID,
+            utbetalingId = BEHANDLING_ID,
+            hendelseId = UUID.randomUUID(),
+            kanAvvises = true,
+            egenskaper = egenskaper.toSet(),
+            totrinnsvurdering = totrinnsvurdering,
         )
     }
 

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

@@ -65,9 +65,10 @@ interface OppgaveDao {
         commandContextId: UUID,
         egenskaper: List<EgenskapForDatabase>,
         vedtaksperiodeId: UUID,
+        behandlingId: UUID,
         utbetalingId: UUID,
         kanAvvises: Boolean,
-    ): Long
+    )
 
     fun finnFødselsnummer(oppgaveId: Long): String
 

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

@@ -9,6 +9,7 @@ data class OppgaveFraDatabase(
     val egenskaper: List<EgenskapForDatabase>,
     val status: String,
     val vedtaksperiodeId: UUID,
+    val behandlingId: UUID,
     val utbetalingId: UUID,
     val hendelseId: UUID,
     val kanAvvises: Boolean,

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

@@ -41,7 +41,7 @@ class PgOppgaveDao(queryRunner: QueryRunner) : OppgaveDao, QueryRunner by queryR
     override fun finnOppgave(id: Long): OppgaveFraDatabase? {
         return asSQL(
             """
-            SELECT o.egenskaper, o.status, v.vedtaksperiode_id, o.ferdigstilt_av, o.ferdigstilt_av_oid, o.utbetaling_id, s.navn, s.epost, s.ident, s.oid, o.kan_avvises
+            SELECT o.egenskaper, o.status, v.vedtaksperiode_id, o.behandling_id, o.ferdigstilt_av, o.ferdigstilt_av_oid, o.utbetaling_id, s.navn, s.epost, s.ident, s.oid, o.kan_avvises
             FROM oppgave o
             INNER JOIN vedtak v on o.vedtak_ref = v.id
             LEFT JOIN tildeling t on o.id = t.oppgave_id_ref
@@ -58,6 +58,7 @@ class PgOppgaveDao(queryRunner: QueryRunner) : OppgaveDao, QueryRunner by queryR
                 egenskaper = egenskaper,
                 status = row.string("status"),
                 vedtaksperiodeId = row.uuid("vedtaksperiode_id"),
+                behandlingId = row.uuid("behandling_id"),
                 utbetalingId = row.uuid("utbetaling_id"),
                 hendelseId = finnHendelseId(id),
                 kanAvvises = row.boolean("kan_avvises"),
@@ -520,18 +521,19 @@ class PgOppgaveDao(queryRunner: QueryRunner) : OppgaveDao, QueryRunner by queryR
         commandContextId: UUID,
         egenskaper: List<EgenskapForDatabase>,
         vedtaksperiodeId: UUID,
+        behandlingId: UUID,
         utbetalingId: UUID,
         kanAvvises: Boolean,
-    ): Long {
+    ) {
         val vedtakRef = vedtakRef(vedtaksperiodeId)
         val personRef = personRef(vedtaksperiodeId)
 
         val (arbeidsgiverBeløp, personBeløp) = finnArbeidsgiverbeløpOgPersonbeløp(vedtaksperiodeId, utbetalingId)
         val mottaker = finnMottaker(arbeidsgiverBeløp > 0, personBeløp > 0)
 
-        return asSQL(
+        asSQL(
             """
-            INSERT INTO oppgave(id, oppdatert, status, ferdigstilt_av, ferdigstilt_av_oid, vedtak_ref, generasjon_ref, command_context_id, utbetaling_id, mottaker, egenskaper, kan_avvises)      
+            INSERT INTO oppgave(id, oppdatert, status, ferdigstilt_av, ferdigstilt_av_oid, vedtak_ref, generasjon_ref, behandling_id, command_context_id, utbetaling_id, mottaker, egenskaper, kan_avvises)      
             SELECT 
                 :id, 
                 now(), 
@@ -544,6 +546,7 @@ class PgOppgaveDao(queryRunner: QueryRunner) : OppgaveDao, QueryRunner by queryR
                         SELECT vedtaksperiode_id FROM vedtak v WHERE v.id = :vedtakRef
                     ) ORDER BY id DESC LIMIT 1
                 ),
+                :behandlingId,
                 :commandContextId, 
                 :utbetalingId,
                 CAST(:mottaker as mottakertype), 
@@ -562,6 +565,7 @@ class PgOppgaveDao(queryRunner: QueryRunner) : OppgaveDao, QueryRunner by queryR
             "ferdigstiltAv" to null,
             "ferdigstiltAvOid" to null,
             "vedtakRef" to vedtakRef,
+            "behandlingId" to behandlingId,
             "commandContextId" to commandContextId,
             "utbetalingId" to utbetalingId,
             "mottaker" to mottaker?.name,

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

@@ -91,6 +91,7 @@ internal class OppgaveService(
         fødselsnummer: String,
         contextId: UUID,
         vedtaksperiodeId: UUID,
+        behandlingId: UUID,
         utbetalingId: UUID,
         hendelseId: UUID,
         kanAvvises: Boolean,
@@ -100,7 +101,16 @@ internal class OppgaveService(
         sikkerlogg.info("Oppretter saksbehandleroppgave for {}", kv("fødselsnummer", fødselsnummer))
         val nesteId = oppgaveDao.reserverNesteId()
         val oppgavemelder = Oppgavemelder(fødselsnummer, rapidsConnection)
-        val oppgave = nyOppgave(nesteId, vedtaksperiodeId, utbetalingId, hendelseId, kanAvvises, egenskaper)
+        val oppgave =
+            nyOppgave(
+                id = nesteId,
+                vedtaksperiodeId = vedtaksperiodeId,
+                behandlingId = behandlingId,
+                utbetalingId = utbetalingId,
+                hendelseId = hendelseId,
+                kanAvvises = kanAvvises,
+                egenskaper = egenskaper,
+            )
         oppgave.register(oppgavemelder)
         oppgavemelder.oppgaveOpprettet(oppgave)
         tildelVedReservasjon(fødselsnummer, oppgave)
@@ -364,12 +374,13 @@ internal class OppgaveService(
         id: Long,
         contextId: UUID,
         vedtaksperiodeId: UUID,
+        behandlingId: UUID,
         utbetalingId: UUID,
         egenskaper: List<EgenskapForDatabase>,
         hendelseId: UUID,
         kanAvvises: Boolean,
     ) {
-        oppgaveDao.opprettOppgave(id, contextId, egenskaper, vedtaksperiodeId, utbetalingId, kanAvvises)
+        oppgaveDao.opprettOppgave(id, contextId, egenskaper, vedtaksperiodeId, behandlingId, utbetalingId, kanAvvises)
         opptegnelseRepository.opprettOpptegnelse(
             oppgaveDao.finnFødselsnummer(id),
             GodkjenningsbehovPayload(hendelseId),

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

@@ -28,6 +28,7 @@ class Oppgavehenter(
                 id = oppgave.id,
                 tilstand = tilstand(oppgave.status),
                 vedtaksperiodeId = oppgave.vedtaksperiodeId,
+                behandlingId = oppgave.behandlingId,
                 utbetalingId = oppgave.utbetalingId,
                 hendelseId = oppgave.hendelseId,
                 kanAvvises = oppgave.kanAvvises,

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

@@ -15,6 +15,7 @@ class Oppgavelagrer(private val tildelingRepository: TildelingRepository) {
             id = oppgaveDto.id,
             contextId = contextId,
             vedtaksperiodeId = oppgaveDto.vedtaksperiodeId,
+            behandlingId = oppgaveDto.behandlingId,
             utbetalingId = oppgaveDto.utbetalingId,
             egenskaper = oppgaveDto.egenskaper.map { it.tilDatabaseversjon() },
             hendelseId = oppgaveDto.hendelseId,

spesialist-selve/src/main/kotlin/no/nav/helse/modell/kommando/OpprettSaksbehandleroppgave.kt

@@ -88,7 +88,17 @@ internal class OpprettSaksbehandleroppgave(
                 .vurderMedlemskap(vedtaksperiodeId)
                 .vurderHaster(vedtaksperiodeId)
 
-        oppgaveService.nyOppgave(fødselsnummer, context.id(), vedtaksperiodeId, utbetalingId, hendelseId, kanAvvises, egenskaper)
+        val behandlingId = behovData.spleisBehandlingId
+        oppgaveService.nyOppgave(
+            fødselsnummer = fødselsnummer,
+            contextId = context.id(),
+            vedtaksperiodeId = vedtaksperiodeId,
+            behandlingId = behandlingId,
+            utbetalingId = utbetalingId,
+            hendelseId = hendelseId,
+            kanAvvises = kanAvvises,
+            egenskaper = egenskaper,
+        )
         return true
     }
 

spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt

@@ -218,6 +218,7 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() {
         utbetalingId: UUID = UTBETALING_ID,
         contextId: UUID = UUID.randomUUID(),
         hendelseId: UUID = UUID.randomUUID(),
+        spleisBehandlingId: UUID = UUID.randomUUID(),
         oppgaveEgenskaper: List<EgenskapForDatabase> = listOf(EGENSKAP),
     ) {
         opprettPerson(fødselsnummer = fødselsnummer, aktørId = aktørId)
@@ -229,12 +230,14 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() {
             periodetype = periodetype,
             inntektskilde = inntektskilde,
             utbetalingId = utbetalingId,
+            spleisBehandlingId = spleisBehandlingId
         )
         opprettOppgave(
             contextId = contextId,
             vedtaksperiodeId = vedtaksperiodeId,
             egenskaper = oppgaveEgenskaper,
             hendelseId = hendelseId,
+            behandlingId = spleisBehandlingId,
         )
     }
 
@@ -377,19 +380,23 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() {
         egenskaper: List<EgenskapForDatabase> = listOf(EGENSKAP),
         kanAvvises: Boolean = true,
         utbetalingId: UUID = UTBETALING_ID,
+        behandlingId: UUID = UUID.randomUUID(),
         hendelseId: UUID = UUID.randomUUID(),
     ) {
         val hendelse = testhendelse(hendelseId = hendelseId)
         opprettCommandContext(hendelse, contextId)
-        oppgaveId =
-            oppgaveDao.opprettOppgave(
-                nextLong().also { OPPGAVE_ID = it },
-                contextId,
-                egenskaper,
-                vedtaksperiodeId,
-                utbetalingId,
-                kanAvvises,
-            )
+        oppgaveId = nextLong()
+        OPPGAVE_ID = oppgaveId
+        oppgaveDao.opprettOppgave(
+            id = oppgaveId,
+            commandContextId = contextId,
+            egenskaper = egenskaper,
+            vedtaksperiodeId = vedtaksperiodeId,
+            behandlingId = behandlingId,
+            utbetalingId = utbetalingId,
+            kanAvvises = kanAvvises,
+        )
+
     }
 
     protected fun avventerSystem(

spesialist-selve/src/test/kotlin/no/nav/helse/db/PgOppgaveDaoTest.kt

@@ -255,14 +255,16 @@ class PgOppgaveDaoTest : DatabaseIntegrationTest() {
     @Test
     fun `finner OppgaveFraDatabase`() {
         val hendelseId = UUID.randomUUID()
-        nyPerson(hendelseId = hendelseId)
+        val behandlingId = UUID.randomUUID()
+        nyPerson(hendelseId = hendelseId, spleisBehandlingId = behandlingId)
         val oppgave = oppgaveDao.finnOppgave(oppgaveId) ?: fail { "Fant ikke oppgave" }
         assertEquals(
             OppgaveFraDatabase(
                 id = oppgaveId,
                 egenskaper = listOf(EGENSKAP),
                 status = "AvventerSaksbehandler",
                 vedtaksperiodeId = VEDTAKSPERIODE,
+                behandlingId = behandlingId,
                 utbetalingId = UTBETALING_ID,
                 hendelseId = hendelseId,
                 kanAvvises = true,
@@ -274,14 +276,16 @@ class PgOppgaveDaoTest : DatabaseIntegrationTest() {
     @Test
     fun `finner OppgaveFraDatabase med flere egenskaper`() {
         val hendelseId = UUID.randomUUID()
-        nyPerson(hendelseId = hendelseId, oppgaveEgenskaper = listOf(EGENSKAP, RISK_QA))
+        val behandlingId = UUID.randomUUID()
+        nyPerson(hendelseId = hendelseId, oppgaveEgenskaper = listOf(EGENSKAP, RISK_QA), spleisBehandlingId = behandlingId)
         val oppgave = oppgaveDao.finnOppgave(oppgaveId) ?: fail { "Fant ikke oppgave" }
         assertEquals(
             OppgaveFraDatabase(
                 id = oppgaveId,
                 egenskaper = listOf(EGENSKAP, RISK_QA),
                 status = "AvventerSaksbehandler",
                 vedtaksperiodeId = VEDTAKSPERIODE,
+                behandlingId = behandlingId,
                 utbetalingId = UTBETALING_ID,
                 hendelseId = hendelseId,
                 kanAvvises = true,