Ikke opprett oppgave for inntektsmeldinger med IkkeFravaer

src/main/kotlin/no/nav/syfo/prosesser/FinnAlleUtgaandeOppgaverProcessor.kt

@@ -1,6 +1,7 @@
 package no.nav.syfo.prosesser
 
 import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.readValue
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import no.nav.helse.arbeidsgiver.utils.RecurringJob
@@ -11,8 +12,11 @@ import no.nav.syfo.client.OppgaveClient
 import no.nav.syfo.dto.Tilstand
 import no.nav.syfo.repository.InntektsmeldingRepository
 import no.nav.syfo.service.BehandlendeEnhetConsumer
+import no.nav.syfo.service.SYKEPENGER_UTLAND
 import no.nav.syfo.util.Metrikk
+import no.nav.syfo.utsattoppgave.BehandlingsKategori
 import no.nav.syfo.utsattoppgave.UtsattOppgaveDAO
+import no.nav.syfo.utsattoppgave.finnBehandlingsKategori
 import no.nav.syfo.utsattoppgave.opprettOppgaveIGosys
 import org.slf4j.LoggerFactory
 import java.time.Duration
@@ -43,22 +47,35 @@ class FinnAlleUtgaandeOppgaverProcessor(
                 }
             }
             .forEach { (oppgaveEntitet, inntektsmeldingEntitet) ->
-                try {
-                    logger.info("Skal opprette oppgave for inntektsmelding: ${oppgaveEntitet.arkivreferanse}")
-                    opprettOppgaveIGosys(
-                        oppgaveEntitet,
-                        oppgaveClient,
-                        utsattOppgaveDAO,
-                        behandlendeEnhetConsumer,
-                        oppgaveEntitet.speil,
-                        inntektsmeldingEntitet,
-                        om
+                val inntektsmelding = om.readValue<no.nav.syfo.domain.inntektsmelding.Inntektsmelding>(inntektsmeldingEntitet.data!!)
+                val behandlendeEnhet =
+                    behandlendeEnhetConsumer.hentBehandlendeEnhet(
+                        oppgaveEntitet.fnr,
+                        oppgaveEntitet.inntektsmeldingId,
                     )
-                    oppgaveEntitet.tilstand = Tilstand.OpprettetTimeout
+                val gjelderUtland = (SYKEPENGER_UTLAND == behandlendeEnhet)
+                logger.info("Fant enhet $behandlendeEnhet for ${oppgaveEntitet.arkivreferanse}")
+                val behandlingsKategori = finnBehandlingsKategori(inntektsmelding, oppgaveEntitet.speil, gjelderUtland)
+                try {
+                    if (behandlingsKategori != BehandlingsKategori.IKKE_FRAVAER) {
+                        logger.info("Skal opprette oppgave for inntektsmelding: ${oppgaveEntitet.arkivreferanse}")
+                        opprettOppgaveIGosys(
+                            oppgaveEntitet,
+                            oppgaveClient,
+                            utsattOppgaveDAO,
+                            behandlingsKategori
+                        )
+                        logger.info("Oppgave opprettet i gosys pga timeout for inntektsmelding: ${oppgaveEntitet.arkivreferanse}")
+                        oppgaveEntitet.tilstand = Tilstand.OpprettetTimeout
+                    }
+                    else {
+                        logger.info("Skal ikke opprette oppgave for inntektsmelding: ${oppgaveEntitet.arkivreferanse}")
+                        sikkerlogger.info("Skal ikke opprette oppgave for inntektsmelding: ${oppgaveEntitet.arkivreferanse} grunnet ${behandlingsKategori.name}")
+                        oppgaveEntitet.tilstand = Tilstand.Forkastet
+                    }
                     oppgaveEntitet.oppdatert = LocalDateTime.now()
                     metrikk.tellUtsattOppgave_OpprettTimeout()
                     utsattOppgaveDAO.lagre(oppgaveEntitet)
-                    logger.info("Oppgave opprettet i gosys pga timeout for inntektsmelding: ${oppgaveEntitet.arkivreferanse}")
                 } catch (e: OpprettOppgaveException) {
                     sikkerlogger.error("Feilet ved opprettelse av oppgave ved timeout i gosys for inntektsmelding: ${oppgaveEntitet.arkivreferanse}", e)
                     logger.error("Feilet ved opprettelse av oppgave ved timeout i gosys for inntektsmelding: ${oppgaveEntitet.arkivreferanse}")

src/main/kotlin/no/nav/syfo/utsattoppgave/FinnBehandlingsKategori.kt

@@ -10,11 +10,13 @@ enum class BehandlingsKategori {
     REFUSJON_UTEN_DATO,
     REFUSJON_MED_DATO,
     REFUSJON_LITEN_LØNN,
-    BESTRIDER_SYKEMELDING
+    BESTRIDER_SYKEMELDING,
+    IKKE_FRAVAER
 }
 
 fun finnBehandlingsKategori(inntektsmelding: Inntektsmelding, speilRelatert: Boolean, gjelderUtland: Boolean): BehandlingsKategori =
     when {
+        inntektsmelding.begrunnelseRedusert == "IkkeFravaer" -> BehandlingsKategori.IKKE_FRAVAER
         speilRelatert -> BehandlingsKategori.SPEIL_RELATERT
         gjelderUtland -> BehandlingsKategori.UTLAND
         inntektsmelding.begrunnelseRedusert == "BetvilerArbeidsufoerhet" -> BehandlingsKategori.BESTRIDER_SYKEMELDING

src/main/kotlin/no/nav/syfo/utsattoppgave/UtsattOppgaveService.kt

@@ -8,14 +8,12 @@ import no.nav.helsearbeidsgiver.utils.log.sikkerLogger
 import no.nav.syfo.client.OppgaveClient
 import no.nav.syfo.domain.OppgaveResultat
 import no.nav.syfo.domain.inntektsmelding.Inntektsmelding
-import no.nav.syfo.dto.InntektsmeldingEntitet
 import no.nav.syfo.dto.Tilstand
 import no.nav.syfo.dto.UtsattOppgaveEntitet
 import no.nav.syfo.repository.InntektsmeldingRepository
 import no.nav.syfo.service.BehandlendeEnhetConsumer
 import no.nav.syfo.service.SYKEPENGER_UTLAND
 import no.nav.syfo.util.Metrikk
-import org.slf4j.LoggerFactory
 import java.time.LocalDateTime
 import java.util.UUID
 
@@ -60,17 +58,28 @@ class UtsattOppgaveService(
             }
             (Tilstand.Utsatt to Handling.Opprett),
             (Tilstand.Forkastet to Handling.Opprett) -> {
-                val inntektsmeldingEntitet = inntektsmeldingRepository.findByUuid(oppgave.inntektsmeldingId)
-
-                if (inntektsmeldingEntitet != null) {
-                    val resultat = opprettOppgave(oppgave, gjelderSpeil, inntektsmeldingEntitet)
-                    oppgave.oppdatert = LocalDateTime.now()
-                    lagre(oppgave.copy(tilstand = Tilstand.Opprettet, speil = gjelderSpeil))
-                    metrikk.tellUtsattOppgave_Opprett()
-                    logger.info("Endret oppgave: ${oppgave.inntektsmeldingId} til tilstand: ${Tilstand.Opprettet.name} gosys oppgaveID: ${resultat.oppgaveId} duplikat? ${resultat.duplikat}")
-                } else {
-                    sikkerlogger.error("Fant ikke inntektsmelding for ID '${oppgave.inntektsmeldingId}'.")
-                }
+                hentInntektsmelding(oppgave)
+                    .onSuccess { inntektsmelding ->
+                        val behandlingsKategori = utledBehandlingsKategori(oppgave, inntektsmelding)
+                        if (BehandlingsKategori.IKKE_FRAVAER != behandlingsKategori) {
+                            val resultat = opprettOppgave(oppgave, behandlingsKategori)
+                            oppgave.oppdatert = LocalDateTime.now()
+                            lagre(oppgave.copy(tilstand = Tilstand.Opprettet, speil = gjelderSpeil))
+                            metrikk.tellUtsattOppgave_Opprett()
+                            logger.info(
+                                "Endret oppgave: ${oppgave.inntektsmeldingId} til tilstand: ${Tilstand.Opprettet.name} gosys oppgaveID: ${resultat.oppgaveId} duplikat? ${resultat.duplikat}",
+                            )
+                        } else {
+                            if (oppgave.tilstand == Tilstand.Utsatt) {
+                                oppgave.oppdatert = LocalDateTime.now()
+                                lagre(oppgave.copy(tilstand = Tilstand.Forkastet, speil = gjelderSpeil))
+                                sikkerlogger.info("Endret oppgave: ${oppgave.inntektsmeldingId} til tilstand: ${Tilstand.Forkastet.name} grunnet behandlingskategori: $behandlingsKategori")
+                            }
+                            logger.info("Oppgave: ${oppgave.inntektsmeldingId} blir ikke opprettet")
+                            sikkerlogger.info("Oppgave: ${oppgave.inntektsmeldingId} har behandlingskategori: $behandlingsKategori og blir ikke opprettet")
+                        }
+                    }
+                    .onFailure { sikkerlogger.error(it.message, it) }
             }
             else -> {
                 metrikk.tellUtsattOppgave_Irrelevant()
@@ -86,37 +95,42 @@ class UtsattOppgaveService(
         utsattOppgaveDAO.opprett(utsattOppgave)
     }
 
-    fun opprettOppgave(oppgave: UtsattOppgaveEntitet, gjelderSpeil: Boolean, inntektsmeldingEntitet: InntektsmeldingEntitet): OppgaveResultat {
-        return opprettOppgaveIGosys(oppgave, oppgaveClient, utsattOppgaveDAO, behandlendeEnhetConsumer, gjelderSpeil, inntektsmeldingEntitet, om)
+    fun hentInntektsmelding(oppgave: UtsattOppgaveEntitet): Result<Inntektsmelding> {
+        val inntektsmelding = inntektsmeldingRepository.findByUuid(oppgave.inntektsmeldingId)
+        return if (inntektsmelding != null && inntektsmelding.data != null) {
+            Result.success(om.readValue<Inntektsmelding>(inntektsmelding.data!!))
+        } else {
+            Result.failure(Exception("Fant ikke inntektsmelding for ID '${oppgave.inntektsmeldingId}'."))
+        }
+    }
+
+    fun utledBehandlingsKategori(oppgave: UtsattOppgaveEntitet, inntektsmelding: Inntektsmelding): BehandlingsKategori {
+        val behandlendeEnhet = behandlendeEnhetConsumer.hentBehandlendeEnhet(oppgave.fnr, oppgave.inntektsmeldingId)
+        logger.info("Fant enhet $behandlendeEnhet for ${oppgave.arkivreferanse}")
+        val gjelderUtland = (SYKEPENGER_UTLAND == behandlendeEnhet)
+        return finnBehandlingsKategori(inntektsmelding, oppgave.speil, gjelderUtland)
     }
+
+    fun opprettOppgave(
+        oppgave: UtsattOppgaveEntitet,
+        behandlingsKategori: BehandlingsKategori
+    ): OppgaveResultat = opprettOppgaveIGosys(oppgave, oppgaveClient, utsattOppgaveDAO, behandlingsKategori)
 }
 
 fun opprettOppgaveIGosys(
     utsattOppgave: UtsattOppgaveEntitet,
     oppgaveClient: OppgaveClient,
     utsattOppgaveDAO: UtsattOppgaveDAO,
-    behandlendeEnhetConsumer: BehandlendeEnhetConsumer,
-    speil: Boolean,
-    imEntitet: InntektsmeldingEntitet,
-    om: ObjectMapper
+    behandlingsKategori: BehandlingsKategori
 ): OppgaveResultat {
-    val logger = LoggerFactory.getLogger(UtsattOppgaveService::class.java)!!
-    val behandlendeEnhet = behandlendeEnhetConsumer.hentBehandlendeEnhet(
-        utsattOppgave.fnr,
-        utsattOppgave.inntektsmeldingId
-    )
-    val gjelderUtland = (SYKEPENGER_UTLAND == behandlendeEnhet)
-    val inntektsmelding = om.readValue<Inntektsmelding>(imEntitet.data!!)
-    val behandlingsKategori = finnBehandlingsKategori(inntektsmelding, speil, gjelderUtland)
-    logger.info("Fant enhet $behandlendeEnhet for ${utsattOppgave.arkivreferanse}")
-    val resultat = runBlocking {
-        oppgaveClient.opprettOppgave(
-            journalpostId = utsattOppgave.journalpostId,
-            aktoerId = utsattOppgave.aktørId,
-            behandlingsKategori = behandlingsKategori
-        )
-    }
-    utsattOppgave.enhet = behandlendeEnhet
+    val resultat =
+        runBlocking {
+            oppgaveClient.opprettOppgave(
+                journalpostId = utsattOppgave.journalpostId,
+                aktoerId = utsattOppgave.aktørId,
+                behandlingsKategori = behandlingsKategori,
+            )
+        }
     utsattOppgave.gosysOppgaveId = resultat.oppgaveId.toString()
     utsattOppgave.utbetalingBruker = resultat.utbetalingBruker
     utsattOppgaveDAO.lagre(utsattOppgave)

src/test/kotlin/no/nav/syfo/utsattoppgave/UtsattOppgaveServiceTest.kt

@@ -1,15 +1,23 @@
 package no.nav.syfo.utsattoppgave
 
 import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
+import com.fasterxml.jackson.module.kotlin.KotlinFeature
+import com.fasterxml.jackson.module.kotlin.KotlinModule
+import io.mockk.Called
+import io.mockk.coEvery
+import io.mockk.coVerify
 import io.mockk.every
 import io.mockk.mockk
 import io.mockk.spyk
 import io.mockk.verify
 import no.nav.syfo.client.OppgaveClient
 import no.nav.syfo.domain.OppgaveResultat
+import no.nav.syfo.dto.InntektsmeldingEntitet
 import no.nav.syfo.dto.Tilstand
 import no.nav.syfo.dto.UtsattOppgaveEntitet
 import no.nav.syfo.repository.InntektsmeldingRepository
+import no.nav.syfo.repository.buildIM
 import no.nav.syfo.service.BehandlendeEnhetConsumer
 import no.nav.syfo.util.Metrikk
 import org.junit.jupiter.api.BeforeEach
@@ -26,13 +34,36 @@ open class UtsattOppgaveServiceTest {
     private lateinit var oppgaveService: UtsattOppgaveService
     private var metrikk: Metrikk = mockk(relaxed = true)
     private var inntektsmeldingRepository: InntektsmeldingRepository = mockk(relaxed = true)
-    private var om: ObjectMapper = mockk()
+    private var om: ObjectMapper =
+        ObjectMapper().registerModules(
+            KotlinModule
+                .Builder()
+                .withReflectionCacheSize(512)
+                .configure(KotlinFeature.NullToEmptyCollection, false)
+                .configure(KotlinFeature.NullToEmptyMap, false)
+                .configure(KotlinFeature.NullIsSameAsDefault, false)
+                .configure(KotlinFeature.SingletonSupport, false)
+                .configure(KotlinFeature.StrictNullChecks, false)
+                .build(),
+            JavaTimeModule(),
+        )
+
+    val inntektsmeldingEntitet = InntektsmeldingEntitet(
+        aktorId = "aktoerid-123",
+        behandlet = LocalDateTime.now(),
+        orgnummer = "arb-org-123",
+        journalpostId = "jp-123",
+        data = om.writeValueAsString(buildIM()),
+    )
+    val inntektsmeldingEntitetIkkeFravaer = inntektsmeldingEntitet.copy(data = om.writeValueAsString(buildIM().copy(begrunnelseRedusert = "IkkeFravaer")))
 
     @BeforeEach
     fun setup() {
         oppgaveService = spyk(UtsattOppgaveService(utsattOppgaveDAO, oppgaveClient, behandlendeEnhetConsumer, inntektsmeldingRepository, om, metrikk))
-        every { utsattOppgaveDAO.finn(any()) } returns oppgave
-        every { oppgaveService.opprettOppgave(any(), any(), any()) } returns OppgaveResultat(Random.nextInt(), false, false)
+        every { utsattOppgaveDAO.finn(any()) } returns oppgave.copy()
+        coEvery { oppgaveClient.opprettOppgave(any(), any(), any()) } returns OppgaveResultat(Random.nextInt(), false, false)
+        every { inntektsmeldingRepository.findByUuid(any()) } returns inntektsmeldingEntitet
+        every { behandlendeEnhetConsumer.hentBehandlendeEnhet(any(), any()) } returns "4488"
     }
 
     private val fnr = "fnr"
@@ -58,7 +89,8 @@ open class UtsattOppgaveServiceTest {
             OppdateringstypeDTO.OpprettSpeilRelatert
         )
         oppgaveService.prosesser(oppgaveOppdatering)
-        verify { utsattOppgaveDAO.lagre(eq(oppgave.copy(tilstand = Tilstand.Opprettet, speil = true, timeout = timeout))) }
+        verify { utsattOppgaveDAO.lagre(match { it.tilstand == Tilstand.Opprettet && it.speil && it.timeout == timeout }) }
+        coVerify { oppgaveClient.opprettOppgave(any(), any(), any()) }
     }
 
     @Test
@@ -70,7 +102,8 @@ open class UtsattOppgaveServiceTest {
             OppdateringstypeDTO.Opprett
         )
         oppgaveService.prosesser(oppgaveOppdatering)
-        verify { utsattOppgaveDAO.lagre(eq(oppgave.copy(tilstand = Tilstand.Opprettet, speil = false, timeout = timeout))) }
+        verify { utsattOppgaveDAO.lagre(match { it.tilstand == Tilstand.Opprettet && !it.speil && it.timeout == timeout }) }
+        coVerify { oppgaveClient.opprettOppgave(any(), any(), any()) }
     }
 
     @Test
@@ -83,8 +116,10 @@ open class UtsattOppgaveServiceTest {
             OppdateringstypeDTO.Utsett
         )
         oppgaveService.prosesser(oppgaveOppdatering)
-        verify { utsattOppgaveDAO.lagre(eq(oppgave.copy(tilstand = Tilstand.Utsatt, timeout = nyTimeout))) }
+        verify { utsattOppgaveDAO.lagre(match { it.tilstand == Tilstand.Utsatt && it.timeout == nyTimeout && it.oppdatert != oppgave.oppdatert }) }
+        coVerify { oppgaveClient.opprettOppgave(any(), any(), any()) wasNot Called }
     }
+
     @Test
     fun `Lagrer utsatt oppgave med tilstand Forkastet ved Ferdigbehandlet`() {
         val oppgaveOppdatering = OppgaveOppdatering(
@@ -94,7 +129,39 @@ open class UtsattOppgaveServiceTest {
             OppdateringstypeDTO.Ferdigbehandlet
         )
         oppgaveService.prosesser(oppgaveOppdatering)
-        verify { utsattOppgaveDAO.lagre(eq(oppgave.copy(tilstand = Tilstand.Forkastet, timeout = timeout))) }
+        verify { utsattOppgaveDAO.lagre(match { it.tilstand == Tilstand.Forkastet && it.timeout == timeout && it.oppdatert != oppgave.oppdatert }) }
+        coVerify(exactly = 0) { oppgaveClient.opprettOppgave(any(), any(), any()) }
+    }
+
+    @Test
+    fun `Oppretter Ikke Oppgave hvis begrunnelseRedusert = IkkeFravaer hvis oppgave utsatt`() {
+        every { inntektsmeldingRepository.findByUuid(any()) } returns inntektsmeldingEntitetIkkeFravaer
+        val oppgaveOppdatering = OppgaveOppdatering(
+            UUID.randomUUID(),
+            OppdateringstypeDTO.Opprett.tilHandling(),
+            timeout.plusDays(7),
+            OppdateringstypeDTO.Opprett
+        )
+        oppgaveService.prosesser(oppgaveOppdatering)
+        verify { utsattOppgaveDAO.lagre(match { it.tilstand == Tilstand.Forkastet && it.oppdatert != oppgave.oppdatert }) }
+        coVerify(exactly = 0) { oppgaveClient.opprettOppgave(any(), any(), any()) }
+    }
+
+    @Test
+    fun `Oppretter Ikke Oppgave hvis begrunnelseRedusert = IkkeFravaer og oppgave allerede forkastet`() {
+        every { inntektsmeldingRepository.findByUuid(any()) } returns inntektsmeldingEntitetIkkeFravaer
+        val forkastetTidspunkt = LocalDateTime.of(2023, 4, 6, 9, 0)
+        val forkastetOppgave = oppgave.copy(tilstand = Tilstand.Forkastet, oppdatert = forkastetTidspunkt)
+        every { utsattOppgaveDAO.finn(any()) } returns forkastetOppgave
+        val oppgaveOppdatering = OppgaveOppdatering(
+            UUID.randomUUID(),
+            OppdateringstypeDTO.Opprett.tilHandling(),
+            timeout.plusDays(7),
+            OppdateringstypeDTO.Opprett
+        )
+        oppgaveService.prosesser(oppgaveOppdatering)
+        verify(exactly = 0) { utsattOppgaveDAO.lagre(any()) }
+        coVerify(exactly = 0) { oppgaveClient.opprettOppgave(any(), any(), any()) }
     }
 
     private fun enOppgave(timeout: LocalDateTime, tilstand: Tilstand = Tilstand.Utsatt) = UtsattOppgaveEntitet(