diff --git a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingController.kt b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingController.kt index e4462cdead2..f0808e8d8f6 100644 --- a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingController.kt +++ b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingController.kt @@ -93,8 +93,7 @@ class BehandlingController( @PutMapping(path = ["/{behandlingId}/behandlingstema"], produces = [MediaType.APPLICATION_JSON_VALUE]) fun endreBehandlingstema( @PathVariable behandlingId: Long, - @RequestBody - endreBehandling: RestEndreBehandlingstema, + @RequestBody endreBehandlingstema: RestEndreBehandlingstema, ): ResponseEntity> { tilgangService.validerTilgangTilBehandling(behandlingId = behandlingId, event = AuditLoggerEvent.UPDATE) tilgangService.verifiserHarTilgangTilHandling( @@ -104,11 +103,10 @@ class BehandlingController( tilgangService.validerKanRedigereBehandling(behandlingId) val behandling = - behandlingstemaService.oppdaterBehandlingstema( + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( behandling = behandlingHentOgPersisterService.hent(behandlingId), - overstyrtUnderkategori = endreBehandling.behandlingUnderkategori, - overstyrtKategori = endreBehandling.behandlingKategori, - manueltOppdatert = true, + nyUnderkategori = endreBehandlingstema.behandlingUnderkategori, + nyKategori = endreBehandlingstema.behandlingKategori, ) return ResponseEntity.ok( diff --git a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingService.kt b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingService.kt index 1e1fe676193..1317b0cd4ab 100644 --- a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingService.kt +++ b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingService.kt @@ -78,17 +78,14 @@ class BehandlingService( overstyrtKategori = nyBehandling.kategori, behandlingType = nyBehandling.behandlingType, behandlingÅrsak = nyBehandling.behandlingÅrsak, - kategoriFraLøpendeBehandling = behandlingstemaService.hentLøpendeKategori(fagsak.id), + tilbakefallendeKategori = behandlingstemaService.finnBehandlingKategori(fagsak.id), ) val underkategori = bestemUnderkategori( overstyrtUnderkategori = nyBehandling.underkategori, - underkategoriFraLøpendeBehandling = behandlingstemaService.hentLøpendeUnderkategori(fagsakId = fagsak.id), - underkategoriFraInneværendeBehandling = - behandlingstemaService.hentUnderkategoriFraInneværendeBehandling( - fagsak.id, - ), + løpendeUnderkategoriFraForrigeVedtatteBehandling = behandlingstemaService.finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(fagsakId = fagsak.id), + underkategoriFraAktivBehandling = behandlingstemaService.finnUnderkategoriFraAktivBehandling(fagsakId = fagsak.id), ) val behandling = diff --git a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaService.kt b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaService.kt index 9eb6040942b..3b0c5637c94 100644 --- a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaService.kt +++ b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaService.kt @@ -1,21 +1,24 @@ package no.nav.familie.ba.sak.kjerne.behandling.behandlingstema import jakarta.transaction.Transactional +import no.nav.familie.ba.sak.common.ClockProvider import no.nav.familie.ba.sak.common.FunksjonellFeil import no.nav.familie.ba.sak.integrasjoner.oppgave.OppgaveService import no.nav.familie.ba.sak.kjerne.behandling.BehandlingHentOgPersisterService import no.nav.familie.ba.sak.kjerne.behandling.domene.Behandling import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingKategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingUnderkategori -import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelse import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelseRepository import no.nav.familie.ba.sak.kjerne.eøs.felles.BehandlingId import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingTidslinjeService import no.nav.familie.ba.sak.kjerne.logg.LoggService +import no.nav.familie.ba.sak.kjerne.tidslinje.komposisjon.innholdForTidspunkt +import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.MånedTidspunkt.Companion.tilTidspunkt import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Regelverk import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Vilkår import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.VilkårsvurderingRepository import org.springframework.stereotype.Service +import java.time.YearMonth @Service class BehandlingstemaService( @@ -25,137 +28,169 @@ class BehandlingstemaService( private val oppgaveService: OppgaveService, private val vilkårsvurderingTidslinjeService: VilkårsvurderingTidslinjeService, private val vilkårsvurderingRepository: VilkårsvurderingRepository, + private val clockProvider: ClockProvider, ) { @Transactional - fun oppdaterBehandlingstema( + fun oppdaterBehandlingstemaFraRegistrereSøknadSteg( + behandling: Behandling, + nyUnderkategori: BehandlingUnderkategori, + ): Behandling { + if (behandling.skalBehandlesAutomatisk) { + return behandling + } + return oppdaterBehandlingstemaPåBehandlingHvisNødvendig(behandling, behandling.kategori, nyUnderkategori) + } + + @Transactional + fun oppdaterSaksbehandletBehandlingstema( + behandling: Behandling, + nyKategori: BehandlingKategori, + nyUnderkategori: BehandlingUnderkategori, + ): Behandling { + if (behandling.skalBehandlesAutomatisk) { + throw FunksjonellFeil("Kan ikke oppdatere behandlingstema manuelt på behandlinger som skal behandles automatisk.") + } + val forrigeKategori = behandling.kategori + val forrigeUnderkategori = behandling.underkategori + val oppdatertBehanding = oppdaterBehandlingstemaPåBehandlingHvisNødvendig(behandling, nyKategori, nyUnderkategori) + lagLogginnslagHvisNødvendig(oppdatertBehanding, forrigeKategori, forrigeUnderkategori, nyKategori, nyUnderkategori) + return oppdatertBehanding + } + + @Transactional + fun oppdaterBehandlingstemaForVilkår( behandling: Behandling, - overstyrtKategori: BehandlingKategori? = null, overstyrtUnderkategori: BehandlingUnderkategori? = null, - manueltOppdatert: Boolean = false, ): Behandling { - if (behandling.skalBehandlesAutomatisk) return behandling - if (manueltOppdatert && (overstyrtKategori == null || overstyrtUnderkategori == null)) { - throw FunksjonellFeil("Du må velge behandlingstema.") + if (behandling.skalBehandlesAutomatisk) { + return behandling } + val nyKategori = finnBehandlingKategori(behandling.fagsak.id) + val nyUnderkategori = overstyrtUnderkategori ?: finnUnderkategoriFraAktivBehandling(fagsakId = behandling.fagsak.id) + return oppdaterBehandlingstemaPåBehandlingHvisNødvendig(behandling, nyKategori, nyUnderkategori) + } - val utledetKategori = - bestemKategori( - overstyrtKategori = overstyrtKategori, - kategoriFraSisteIverksattBehandling = hentLøpendeKategori(behandling.fagsak.id), - kategoriFraInneværendeBehandling = hentKategoriFraInneværendeBehandling(behandling.fagsak.id), - ) + fun finnBehandlingKategori(fagsakId: Long): BehandlingKategori { + val aktivBehandling = behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsakId = fagsakId) + val sisteVedtatteBehandling = behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsakId = fagsakId) - val utledetUnderkategori = - bestemUnderkategori( - overstyrtUnderkategori = overstyrtUnderkategori, - underkategoriFraLøpendeBehandling = hentLøpendeUnderkategori(fagsakId = behandling.fagsak.id), - underkategoriFraInneværendeBehandling = hentUnderkategoriFraInneværendeBehandling(fagsakId = behandling.fagsak.id), - ) + if (aktivBehandling == null) { + return sisteVedtatteBehandling?.kategori ?: BehandlingKategori.NASJONAL + } - val forrigeUnderkategori = behandling.underkategori - val forrigeKategori = behandling.kategori - val skalOppdatereKategori = utledetKategori != forrigeKategori - val skalOppdatereUnderkategori = utledetUnderkategori != forrigeUnderkategori - val skalOppdatereKategoriEllerUnderkategori = skalOppdatereKategori || skalOppdatereUnderkategori - - return if (skalOppdatereKategoriEllerUnderkategori) { - behandling.apply { - kategori = utledetKategori - underkategori = utledetUnderkategori - } + val tidslinjer = vilkårsvurderingTidslinjeService.hentTidslinjer(behandlingId = BehandlingId(aktivBehandling.id)) + if (tidslinjer == null) { + return sisteVedtatteBehandling?.kategori ?: BehandlingKategori.NASJONAL + } - behandlingHentOgPersisterService.lagreEllerOppdater(behandling).also { lagretBehandling -> - oppgaveService.patchOppgaverForBehandling(lagretBehandling) { - val lagretUnderkategori = lagretBehandling.underkategori - if (it.behandlingstema != lagretBehandling.tilOppgaveBehandlingTema().value || it.behandlingstype != lagretBehandling.kategori.tilOppgavebehandlingType().value) { - it.copy( - behandlingstema = - when (lagretUnderkategori) { - BehandlingUnderkategori.ORDINÆR, BehandlingUnderkategori.UTVIDET -> - behandling.tilOppgaveBehandlingTema().value - }, - behandlingstype = lagretBehandling.kategori.tilOppgavebehandlingType().value, - ) - } else { - null - } - } - - if (manueltOppdatert) { - loggService.opprettEndretBehandlingstema( - behandling = lagretBehandling, - forrigeKategori = forrigeKategori, - forrigeUnderkategori = forrigeUnderkategori, - nyKategori = utledetKategori, - nyUnderkategori = utledetUnderkategori, - ) - } - } - } else { - behandling + val alleBarnasTidslinjerSomHarLøpendePeriode = + tidslinjer + .barnasTidslinjer() + .values + .map { it.egetRegelverkResultatTidslinje.innholdForTidspunkt(YearMonth.now(clockProvider.get()).tilTidspunkt()) } + + val etBarnHarMinstEnLøpendeEØSPeriode = alleBarnasTidslinjerSomHarLøpendePeriode.any { it.innhold?.regelverk == Regelverk.EØS_FORORDNINGEN } + if (etBarnHarMinstEnLøpendeEØSPeriode) { + return BehandlingKategori.EØS } - } - fun hentLøpendeKategori(fagsakId: Long): BehandlingKategori { - val forrigeVedtatteBehandling = - behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsakId = fagsakId) - ?: return BehandlingKategori.NASJONAL + val etBarnHarMinstEnLøpendeNasjonalPeriode = alleBarnasTidslinjerSomHarLøpendePeriode.any { it.innhold?.regelverk == Regelverk.NASJONALE_REGLER } + if (etBarnHarMinstEnLøpendeNasjonalPeriode) { + return BehandlingKategori.NASJONAL + } - val barnasTidslinjer = - vilkårsvurderingTidslinjeService - .hentTidslinjer(behandlingId = BehandlingId(forrigeVedtatteBehandling.id)) - ?.barnasTidslinjer() - return utledLøpendeKategori(barnasTidslinjer) + return sisteVedtatteBehandling?.kategori ?: BehandlingKategori.NASJONAL } - fun hentKategoriFraInneværendeBehandling(fagsakId: Long): BehandlingKategori { - val aktivBehandling = - behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsakId = fagsakId) - ?: return BehandlingKategori.NASJONAL - val vilkårsvurdering = - vilkårsvurderingRepository.findByBehandlingAndAktiv(behandlingId = aktivBehandling.id) - ?: return aktivBehandling.kategori - val erVilkårMedEØSRegelverkBehandlet = - vilkårsvurdering.personResultater - .flatMap { it.vilkårResultater } - .filter { it.sistEndretIBehandlingId == aktivBehandling.id } - .any { it.vurderesEtter == Regelverk.EØS_FORORDNINGEN } - - return if (erVilkårMedEØSRegelverkBehandlet) { - BehandlingKategori.EØS + fun finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(fagsakId: Long): BehandlingUnderkategori? { + val forrigeVedtatteBehandling = behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsakId = fagsakId) + if (forrigeVedtatteBehandling == null) { + return null + } + val forrigeAndeler = andelTilkjentYtelseRepository.finnAndelerTilkjentYtelseForBehandling(behandlingId = forrigeVedtatteBehandling.id) + return if (forrigeAndeler.any { it.erUtvidet() && it.erLøpende() }) { + BehandlingUnderkategori.UTVIDET } else { - BehandlingKategori.NASJONAL + BehandlingUnderkategori.ORDINÆR } } - fun hentLøpendeUnderkategori(fagsakId: Long): BehandlingUnderkategori? { - val forrigeAndeler = hentForrigeAndeler(fagsakId) - return if (forrigeAndeler != null) utledLøpendeUnderkategori(forrigeAndeler) else null - } + fun finnUnderkategoriFraAktivBehandling(fagsakId: Long): BehandlingUnderkategori { + val aktivBehandling = behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsakId = fagsakId) + if (aktivBehandling == null) { + return BehandlingUnderkategori.ORDINÆR + } - fun hentUnderkategoriFraInneværendeBehandling(fagsakId: Long): BehandlingUnderkategori { - val aktivBehandling = - behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsakId = fagsakId) - ?: return BehandlingUnderkategori.ORDINÆR + val vilkårsvurdering = vilkårsvurderingRepository.findByBehandlingAndAktiv(behandlingId = aktivBehandling.id) + if (vilkårsvurdering == null) { + return BehandlingUnderkategori.ORDINÆR + } val erUtvidetVilkårBehandlet = - vilkårsvurderingRepository - .findByBehandlingAndAktiv(behandlingId = aktivBehandling.id) - ?.personResultater - ?.flatMap { it.vilkårResultater } - ?.filter { it.sistEndretIBehandlingId == aktivBehandling.id } - ?.any { it.vilkårType == Vilkår.UTVIDET_BARNETRYGD } - - return if (erUtvidetVilkårBehandlet == true) { + vilkårsvurdering + .personResultater + .flatMap { it.vilkårResultater } + .filter { it.sistEndretIBehandlingId == aktivBehandling.id } + .any { it.vilkårType == Vilkår.UTVIDET_BARNETRYGD } + + return if (erUtvidetVilkårBehandlet) { BehandlingUnderkategori.UTVIDET } else { BehandlingUnderkategori.ORDINÆR } } - private fun hentForrigeAndeler(fagsakId: Long): List? { - val forrigeVedtatteBehandling = - behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsakId = fagsakId) ?: return null - return andelTilkjentYtelseRepository.finnAndelerTilkjentYtelseForBehandling(behandlingId = forrigeVedtatteBehandling.id) + private fun oppdaterBehandlingstemaPåBehandlingHvisNødvendig( + behandling: Behandling, + nyKategori: BehandlingKategori, + nyUnderkategori: BehandlingUnderkategori, + ): Behandling { + val skalOppdatereKategori = nyKategori != behandling.kategori + val skalOppdatereUnderkategori = nyUnderkategori != behandling.underkategori + if (skalOppdatereKategori || skalOppdatereUnderkategori) { + behandling.kategori = nyKategori + behandling.underkategori = nyUnderkategori + val lagretBehandling = behandlingHentOgPersisterService.lagreEllerOppdater(behandling) + patchBehandlingstemaPåOppgaveForBehandlingHvisNødvendig(lagretBehandling) + return lagretBehandling + } + return behandling + } + + private fun patchBehandlingstemaPåOppgaveForBehandlingHvisNødvendig( + behandling: Behandling, + ) { + oppgaveService.patchOppgaverForBehandling(behandling) { + val behandlingstemaErEndret = it.behandlingstema != behandling.tilOppgaveBehandlingTema().value + val behandlingstypeErEndret = it.behandlingstype != behandling.kategori.tilOppgavebehandlingType().value + if (behandlingstemaErEndret || behandlingstypeErEndret) { + it.copy( + behandlingstema = behandling.tilOppgaveBehandlingTema().value, + behandlingstype = behandling.kategori.tilOppgavebehandlingType().value, + ) + } else { + null + } + } + } + + private fun lagLogginnslagHvisNødvendig( + behandling: Behandling, + forrigeKategori: BehandlingKategori, + forrigeUnderkategori: BehandlingUnderkategori, + nyKategori: BehandlingKategori, + nyUnderkategori: BehandlingUnderkategori, + ) { + val skalOppdatereKategori = nyKategori != forrigeKategori + val skalOppdatereUnderkategori = nyUnderkategori != forrigeUnderkategori + if (skalOppdatereKategori || skalOppdatereUnderkategori) { + loggService.opprettEndretBehandlingstema( + behandling = behandling, + forrigeKategori = forrigeKategori, + forrigeUnderkategori = forrigeUnderkategori, + nyKategori = nyKategori, + nyUnderkategori = nyUnderkategori, + ) + } } } diff --git a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaUtils.kt b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaUtils.kt index ec4a7a92dac..f17ef66e865 100644 --- a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaUtils.kt +++ b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaUtils.kt @@ -5,20 +5,12 @@ import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingKategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingType import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingUnderkategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingÅrsak -import no.nav.familie.ba.sak.kjerne.behandling.domene.finnHøyesteKategori -import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelse -import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingTidslinjer -import no.nav.familie.ba.sak.kjerne.personident.Aktør -import no.nav.familie.ba.sak.kjerne.tidslinje.komposisjon.innholdForTidspunkt -import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.MånedTidspunkt -import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Regelverk fun bestemKategoriVedOpprettelse( overstyrtKategori: BehandlingKategori?, behandlingType: BehandlingType, behandlingÅrsak: BehandlingÅrsak, - // siste iverksatt behandling som har løpende utbetaling. Hvis løpende utbetaling ikke finnes, settes det til NASJONAL - kategoriFraLøpendeBehandling: BehandlingKategori, + tilbakefallendeKategori: BehandlingKategori, ): BehandlingKategori = when { behandlingType == BehandlingType.FØRSTEGANGSBEHANDLING || @@ -39,59 +31,18 @@ fun bestemKategoriVedOpprettelse( } else -> { - kategoriFraLøpendeBehandling + tilbakefallendeKategori } } -fun bestemKategori( - overstyrtKategori: BehandlingKategori?, - // kategori fra siste iverksatt behandling eller NASJONAL når det ikke finnes noe - kategoriFraSisteIverksattBehandling: BehandlingKategori, - kategoriFraInneværendeBehandling: BehandlingKategori, -): BehandlingKategori { - // når saksbehandler overstyrer behandlingstema manuelt - if (overstyrtKategori != null) return overstyrtKategori - - // når saken har en løpende EØS utbetaling - if (kategoriFraSisteIverksattBehandling == BehandlingKategori.EØS) return BehandlingKategori.EØS - - // når løpende utbetaling er NASJONAL og inneværende behandling får EØS - val oppdatertKategori = - listOf(kategoriFraSisteIverksattBehandling, kategoriFraInneværendeBehandling).finnHøyesteKategori() - - return oppdatertKategori ?: BehandlingKategori.NASJONAL -} - fun bestemUnderkategori( overstyrtUnderkategori: BehandlingUnderkategori?, - underkategoriFraLøpendeBehandling: BehandlingUnderkategori?, - underkategoriFraInneværendeBehandling: BehandlingUnderkategori? = null, + løpendeUnderkategoriFraForrigeVedtatteBehandling: BehandlingUnderkategori?, + underkategoriFraAktivBehandling: BehandlingUnderkategori? = null, ): BehandlingUnderkategori { - if (underkategoriFraLøpendeBehandling == BehandlingUnderkategori.UTVIDET) return BehandlingUnderkategori.UTVIDET - - val oppdatertUnderkategori = overstyrtUnderkategori ?: underkategoriFraInneværendeBehandling - - return oppdatertUnderkategori ?: BehandlingUnderkategori.ORDINÆR -} - -fun utledLøpendeUnderkategori(andeler: List): BehandlingUnderkategori = if (andeler.any { it.erUtvidet() && it.erLøpende() }) BehandlingUnderkategori.UTVIDET else BehandlingUnderkategori.ORDINÆR - -fun utledLøpendeKategori( - barnasTidslinjer: Map?, -): BehandlingKategori { - if (barnasTidslinjer == null) return BehandlingKategori.NASJONAL - - val nå = MånedTidspunkt.nå() - - val etBarnHarMinstEnLøpendeEØSPeriode = - barnasTidslinjer - .values - .map { it.egetRegelverkResultatTidslinje.innholdForTidspunkt(nå) } - .any { it.innhold?.regelverk == Regelverk.EØS_FORORDNINGEN } - - return if (etBarnHarMinstEnLøpendeEØSPeriode) { - BehandlingKategori.EØS - } else { - BehandlingKategori.NASJONAL + if (løpendeUnderkategoriFraForrigeVedtatteBehandling == BehandlingUnderkategori.UTVIDET) { + return BehandlingUnderkategori.UTVIDET } + val oppdatertUnderkategori = overstyrtUnderkategori ?: underkategoriFraAktivBehandling + return oppdatertUnderkategori ?: BehandlingUnderkategori.ORDINÆR } diff --git a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/fagsak/FagsakService.kt b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/fagsak/FagsakService.kt index 11dd277053d..7fe38e3d892 100644 --- a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/fagsak/FagsakService.kt +++ b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/fagsak/FagsakService.kt @@ -19,7 +19,6 @@ import no.nav.familie.ba.sak.integrasjoner.skyggesak.SkyggesakService import no.nav.familie.ba.sak.kjerne.behandling.BehandlingHentOgPersisterService import no.nav.familie.ba.sak.kjerne.behandling.BehandlingService import no.nav.familie.ba.sak.kjerne.behandling.UtvidetBehandlingService -import no.nav.familie.ba.sak.kjerne.behandling.behandlingstema.BehandlingstemaService import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingStatus import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelseRepository import no.nav.familie.ba.sak.kjerne.beregning.domene.YtelseType @@ -50,7 +49,6 @@ class FagsakService( private val personRepository: PersonRepository, private val andelerTilkjentYtelseRepository: AndelTilkjentYtelseRepository, private val personidentService: PersonidentService, - private val behandlingstemaService: BehandlingstemaService, private val utvidetBehandlingService: UtvidetBehandlingService, private val behandlingService: BehandlingService, private val vedtakRepository: VedtakRepository, @@ -244,8 +242,8 @@ class FagsakService( } else { aktivBehandling.status == BehandlingStatus.UTREDES || (aktivBehandling.steg >= StegType.BESLUTTE_VEDTAK && aktivBehandling.steg != StegType.BEHANDLING_AVSLUTTET) }, - løpendeKategori = behandlingstemaService.hentLøpendeKategori(fagsakId = fagsakId), - løpendeUnderkategori = behandlingstemaService.hentLøpendeUnderkategori(fagsakId = fagsakId), + løpendeKategori = (aktivBehandling ?: sistVedtatteBehandling)?.kategori, + løpendeUnderkategori = (aktivBehandling ?: sistVedtatteBehandling)?.underkategori, gjeldendeUtbetalingsperioder = gjeldendeUtbetalingsperioder, fagsakType = fagsak.type, institusjon = diff --git "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knad.kt" "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knad.kt" index b0601eb62fb..4c00469e69f 100644 --- "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knad.kt" +++ "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knad.kt" @@ -33,9 +33,9 @@ class RegistrereSøknad( val innsendtSøknad = søknadDTO.writeValueAsString() if (behandling.underkategori != søknadDTO.underkategori.tilDomene()) { - behandlingstemaService.oppdaterBehandlingstema( - behandling = behandlingHentOgPersisterService.hent(behandlingId = behandling.id), - overstyrtUnderkategori = søknadDTO.underkategori.tilDomene(), + behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg( + behandling = behandling, + nyUnderkategori = søknadDTO.underkategori.tilDomene(), ) } @@ -51,14 +51,14 @@ class RegistrereSøknad( val forrigeBehandlingSomErVedtatt = behandlingHentOgPersisterService.hentForrigeBehandlingSomErVedtatt(behandling = behandling) persongrunnlagService.registrerBarnFraSøknad( - behandling = behandlingHentOgPersisterService.hent(behandlingId = behandling.id), + behandling = behandling, forrigeBehandlingSomErVedtatt = forrigeBehandlingSomErVedtatt, søknadDTO = søknadDTO, ) // TODO: Fjern EndretUtbetalingAndel for personer som ikke lenger er relevant for behandlingen tilbakestillBehandlingService.initierOgSettBehandlingTilVilkårsvurdering( - behandling = behandlingHentOgPersisterService.hent(behandlingId = behandling.id), + behandling = behandling, bekreftEndringerViaFrontend = data.bekreftEndringerViaFrontend, ) @@ -66,7 +66,7 @@ class RegistrereSøknad( vedtakService.oppdater(vedtak) - return hentNesteStegForNormalFlyt(behandling = behandlingHentOgPersisterService.hent(behandlingId = behandling.id)) + return hentNesteStegForNormalFlyt(behandling = behandling) } override fun stegType(): StegType = StegType.REGISTRERE_SØKNAD diff --git "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/Vilk\303\245rsvurderingSteg.kt" "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/Vilk\303\245rsvurderingSteg.kt" index 1e5b792d1c3..a0e3a77cd41 100644 --- "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/Vilk\303\245rsvurderingSteg.kt" +++ "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/Vilk\303\245rsvurderingSteg.kt" @@ -103,7 +103,7 @@ class VilkårsvurderingSteg( automatiskOppdaterValutakursService.oppdaterAndelerMedValutakurser(BehandlingId(behandling.id)) - behandlingstemaService.oppdaterBehandlingstema( + behandlingstemaService.oppdaterBehandlingstemaForVilkår( behandling = behandlingHentOgPersisterService.hent(behandlingId = behandling.id), ) diff --git "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/grunnlagForNyBehandling/Vilk\303\245rsvurderingForNyBehandlingService.kt" "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/grunnlagForNyBehandling/Vilk\303\245rsvurderingForNyBehandlingService.kt" index a803cd27750..dbfd7c31637 100644 --- "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/grunnlagForNyBehandling/Vilk\303\245rsvurderingForNyBehandlingService.kt" +++ "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/steg/grunnlagForNyBehandling/Vilk\303\245rsvurderingForNyBehandlingService.kt" @@ -185,7 +185,7 @@ class VilkårsvurderingForNyBehandlingService( initiellVilkårsvurdering = initiellVilkårsvurdering, ) - val løpendeUnderkategori = behandlingstemaService.hentLøpendeUnderkategori(behandling.fagsak.id) + val løpendeUnderkategori = behandlingstemaService.finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(behandling.fagsak.id) val finnesVilkårsvurderingPåInneværendeBehandling = aktivVilkårsvurdering != null val førsteVilkårsvurderingPåBehandlingOgFinnesTidligereVedtattBehandling = diff --git "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rService.kt" "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rService.kt" index b7e3fa5aa84..63ee56696e1 100644 --- "a/src/main/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rService.kt" +++ "b/src/main/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rService.kt" @@ -127,7 +127,7 @@ class VilkårService( .forEach { personResultat.removeVilkårResultat(it.id) } if (restSlettVilkår.vilkårType == Vilkår.UTVIDET_BARNETRYGD) { - behandlingstemaService.oppdaterBehandlingstema( + behandlingstemaService.oppdaterBehandlingstemaForVilkår( behandling = behandling, overstyrtUnderkategori = BehandlingUnderkategori.ORDINÆR, ) @@ -148,7 +148,7 @@ class VilkårService( if (restNyttVilkår.vilkårType == Vilkår.UTVIDET_BARNETRYGD) { validerFørLeggeTilUtvidetBarnetrygd(behandling, restNyttVilkår, vilkårsvurdering) - behandlingstemaService.oppdaterBehandlingstema( + behandlingstemaService.oppdaterBehandlingstemaForVilkår( behandling = behandling, overstyrtUnderkategori = BehandlingUnderkategori.UTVIDET, ) diff --git a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/common/DataGenerator.kt b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/common/DataGenerator.kt index 0344e24a956..f0cb590a67f 100644 --- a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/common/DataGenerator.kt +++ b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/common/DataGenerator.kt @@ -1298,6 +1298,7 @@ fun lagVilkårResultat( ) fun lagVilkårResultat( + id: Long = 0L, personResultat: PersonResultat? = null, vilkårType: Vilkår = Vilkår.BOSATT_I_RIKET, resultat: Resultat = Resultat.OPPFYLT, @@ -1308,7 +1309,9 @@ fun lagVilkårResultat( utdypendeVilkårsvurderinger: List = emptyList(), erEksplisittAvslagPåSøknad: Boolean = false, standardbegrunnelser: List = emptyList(), + vurderesEtter: Regelverk? = null, ) = VilkårResultat( + id = id, personResultat = personResultat, vilkårType = vilkårType, resultat = resultat, @@ -1319,6 +1322,7 @@ fun lagVilkårResultat( utdypendeVilkårsvurderinger = utdypendeVilkårsvurderinger, erEksplisittAvslagPåSøknad = erEksplisittAvslagPåSøknad, standardbegrunnelser = standardbegrunnelser, + vurderesEtter = vurderesEtter, ) val guttenBarnesenFødselsdato = LocalDate.now().withDayOfMonth(10).minusYears(6) @@ -1426,20 +1430,21 @@ fun lagPerson( fun lagPersonEnkel( personType: PersonType, aktør: Aktør = randomAktør(), + dødsfallDato: LocalDate? = null, + fødselsdato: LocalDate = + if (personType == PersonType.SØKER) { + LocalDate.now().minusYears(34) + } else { + LocalDate.now().minusYears(4) + }, + målform: Målform = Målform.NB, ): PersonEnkel = PersonEnkel( type = personType, aktør = aktør, - dødsfallDato = null, - fødselsdato = - if (personType == PersonType.SØKER) { - LocalDate.now().minusYears(34) - } else { - LocalDate - .now() - .minusYears(4) - }, - målform = Målform.NB, + dødsfallDato = dødsfallDato, + fødselsdato = fødselsdato, + målform = målform, ) fun lagRestSanityBegrunnelse( diff --git a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingUtilsTest.kt b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingUtilsTest.kt index 68efc27b5af..a9ee70a0c21 100644 --- a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingUtilsTest.kt +++ b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/BehandlingUtilsTest.kt @@ -2,19 +2,14 @@ package no.nav.familie.ba.sak.kjerne.behandling import no.nav.familie.ba.sak.common.FunksjonellFeil import no.nav.familie.ba.sak.common.lagBehandling -import no.nav.familie.ba.sak.common.randomAktør import no.nav.familie.ba.sak.kjerne.behandling.Behandlingutils.validerBehandlingIkkeSendtTilEksterneTjenester import no.nav.familie.ba.sak.kjerne.behandling.behandlingstema.bestemKategoriVedOpprettelse import no.nav.familie.ba.sak.kjerne.behandling.behandlingstema.bestemUnderkategori -import no.nav.familie.ba.sak.kjerne.behandling.behandlingstema.utledLøpendeUnderkategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingKategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingType import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingUnderkategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingÅrsak import no.nav.familie.ba.sak.kjerne.behandling.domene.tilstand.BehandlingStegTilstand -import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelse -import no.nav.familie.ba.sak.kjerne.beregning.domene.TilkjentYtelse -import no.nav.familie.ba.sak.kjerne.beregning.domene.YtelseType import no.nav.familie.ba.sak.kjerne.steg.BehandlingStegStatus import no.nav.familie.ba.sak.kjerne.steg.StegType import org.junit.jupiter.api.Assertions.assertEquals @@ -22,8 +17,6 @@ import org.junit.jupiter.api.Assertions.assertFalse import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows -import java.math.BigDecimal -import java.time.LocalDate import java.time.YearMonth class BehandlingUtilsTest { @@ -33,7 +26,7 @@ class BehandlingUtilsTest { BehandlingUnderkategori.ORDINÆR, bestemUnderkategori( overstyrtUnderkategori = BehandlingUnderkategori.ORDINÆR, - underkategoriFraLøpendeBehandling = null, + løpendeUnderkategoriFraForrigeVedtatteBehandling = null, ), ) } @@ -44,7 +37,7 @@ class BehandlingUtilsTest { BehandlingUnderkategori.UTVIDET, bestemUnderkategori( overstyrtUnderkategori = BehandlingUnderkategori.UTVIDET, - underkategoriFraLøpendeBehandling = null, + løpendeUnderkategoriFraForrigeVedtatteBehandling = null, ), ) } @@ -55,8 +48,8 @@ class BehandlingUtilsTest { BehandlingUnderkategori.UTVIDET, bestemUnderkategori( overstyrtUnderkategori = null, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.ORDINÆR, - underkategoriFraInneværendeBehandling = BehandlingUnderkategori.UTVIDET, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.ORDINÆR, + underkategoriFraAktivBehandling = BehandlingUnderkategori.UTVIDET, ), ) } @@ -67,8 +60,8 @@ class BehandlingUtilsTest { BehandlingUnderkategori.UTVIDET, bestemUnderkategori( overstyrtUnderkategori = BehandlingUnderkategori.ORDINÆR, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.UTVIDET, - underkategoriFraInneværendeBehandling = BehandlingUnderkategori.ORDINÆR, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.UTVIDET, + underkategoriFraAktivBehandling = BehandlingUnderkategori.ORDINÆR, ), ) } @@ -79,7 +72,7 @@ class BehandlingUtilsTest { BehandlingUnderkategori.UTVIDET, bestemUnderkategori( overstyrtUnderkategori = BehandlingUnderkategori.ORDINÆR, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.UTVIDET, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.UTVIDET, ), ) } @@ -90,7 +83,7 @@ class BehandlingUtilsTest { BehandlingUnderkategori.ORDINÆR, bestemUnderkategori( overstyrtUnderkategori = BehandlingUnderkategori.ORDINÆR, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.ORDINÆR, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.ORDINÆR, ), ) } @@ -101,7 +94,7 @@ class BehandlingUtilsTest { BehandlingUnderkategori.UTVIDET, bestemUnderkategori( overstyrtUnderkategori = BehandlingUnderkategori.UTVIDET, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.ORDINÆR, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.ORDINÆR, ), ) } @@ -112,120 +105,18 @@ class BehandlingUtilsTest { BehandlingUnderkategori.UTVIDET, bestemUnderkategori( overstyrtUnderkategori = null, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.UTVIDET, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.UTVIDET, ), ) assertEquals( BehandlingUnderkategori.ORDINÆR, bestemUnderkategori( overstyrtUnderkategori = null, - underkategoriFraLøpendeBehandling = BehandlingUnderkategori.ORDINÆR, + løpendeUnderkategoriFraForrigeVedtatteBehandling = BehandlingUnderkategori.ORDINÆR, ), ) } - @Test - fun `Skal returnere utvidet hvis det eksisterer en løpende utvidet-sak`() { - val søkerAktørId = randomAktør() - - val behandling = lagBehandling() - - val tilkjentYtelse = - TilkjentYtelse( - behandling = behandling, - opprettetDato = LocalDate.now(), - endretDato = LocalDate.now(), - ) - - val andelTilkjentYtelse = - listOf( - AndelTilkjentYtelse( - behandlingId = behandling.id, - type = YtelseType.UTVIDET_BARNETRYGD, - tilkjentYtelse = tilkjentYtelse, - aktør = søkerAktørId, - kalkulertUtbetalingsbeløp = 1054, - nasjonaltPeriodebeløp = 1054, - sats = 123, - stønadFom = YearMonth.of(2015, 6), - stønadTom = YearMonth.now().plusYears(5), - prosent = BigDecimal(2), - ), - ) - - val løpendeUndekategori = utledLøpendeUnderkategori(andelTilkjentYtelse) - - assertEquals(BehandlingUnderkategori.UTVIDET, løpendeUndekategori) - } - - @Test - fun `Skal returnere ordinær hvis det eksisterer en utvidet-sak som er avsluttet`() { - val søkerAktørId = randomAktør() - - val behandling = lagBehandling() - - val tilkjentYtelse = - TilkjentYtelse( - behandling = behandling, - opprettetDato = LocalDate.now(), - endretDato = LocalDate.now(), - ) - - val andelTilkjentYtelse = - listOf( - AndelTilkjentYtelse( - behandlingId = behandling.id, - type = YtelseType.UTVIDET_BARNETRYGD, - tilkjentYtelse = tilkjentYtelse, - aktør = søkerAktørId, - kalkulertUtbetalingsbeløp = 1054, - nasjonaltPeriodebeløp = 1054, - sats = 123, - stønadFom = YearMonth.of(2015, 6), - stønadTom = YearMonth.now().minusYears(1), - prosent = BigDecimal(2), - ), - ) - - val løpendeUndekategori = utledLøpendeUnderkategori(andelTilkjentYtelse) - - assertEquals(BehandlingUnderkategori.ORDINÆR, løpendeUndekategori) - } - - @Test - fun `Skal returnere ordinær hvis det eksisterer en løpende ordinær-sak`() { - val søkerAktørId = randomAktør() - - val behandling = lagBehandling() - - val tilkjentYtelse = - TilkjentYtelse( - behandling = behandling, - opprettetDato = LocalDate.now(), - endretDato = LocalDate.now(), - ) - - val andelTilkjentYtelse = - listOf( - AndelTilkjentYtelse( - behandlingId = behandling.id, - type = YtelseType.ORDINÆR_BARNETRYGD, - tilkjentYtelse = tilkjentYtelse, - aktør = søkerAktørId, - kalkulertUtbetalingsbeløp = 1054, - nasjonaltPeriodebeløp = 1054, - sats = 123, - stønadFom = YearMonth.of(2015, 6), - stønadTom = YearMonth.now().plusYears(2), - prosent = BigDecimal(2), - ), - ) - - val løpendeUndekategori = utledLøpendeUnderkategori(andelTilkjentYtelse) - - assertEquals(BehandlingUnderkategori.ORDINÆR, løpendeUndekategori) - } - @Test fun `Skal finne ut at omregningsbehandling allerede har kjørt inneværende måned`() { val fgb = lagBehandling() @@ -309,7 +200,7 @@ class BehandlingUtilsTest { overstyrtKategori = BehandlingKategori.EØS, behandlingType = BehandlingType.FØRSTEGANGSBEHANDLING, behandlingÅrsak = BehandlingÅrsak.SØKNAD, - kategoriFraLøpendeBehandling = BehandlingKategori.NASJONAL, + tilbakefallendeKategori = BehandlingKategori.NASJONAL, ), ) } @@ -322,7 +213,7 @@ class BehandlingUtilsTest { overstyrtKategori = BehandlingKategori.EØS, behandlingType = BehandlingType.REVURDERING, behandlingÅrsak = BehandlingÅrsak.SØKNAD, - kategoriFraLøpendeBehandling = BehandlingKategori.NASJONAL, + tilbakefallendeKategori = BehandlingKategori.NASJONAL, ), ) } @@ -336,7 +227,7 @@ class BehandlingUtilsTest { overstyrtKategori = overstyrtKategori, behandlingType = BehandlingType.MIGRERING_FRA_INFOTRYGD, behandlingÅrsak = BehandlingÅrsak.HELMANUELL_MIGRERING, - kategoriFraLøpendeBehandling = BehandlingKategori.NASJONAL, + tilbakefallendeKategori = BehandlingKategori.NASJONAL, ), ) } @@ -349,7 +240,7 @@ class BehandlingUtilsTest { overstyrtKategori = BehandlingKategori.NASJONAL, behandlingType = BehandlingType.MIGRERING_FRA_INFOTRYGD, behandlingÅrsak = BehandlingÅrsak.MIGRERING, - kategoriFraLøpendeBehandling = BehandlingKategori.NASJONAL, + tilbakefallendeKategori = BehandlingKategori.NASJONAL, ), ) } @@ -362,7 +253,7 @@ class BehandlingUtilsTest { overstyrtKategori = BehandlingKategori.EØS, behandlingType = BehandlingType.MIGRERING_FRA_INFOTRYGD, behandlingÅrsak = BehandlingÅrsak.MIGRERING, - kategoriFraLøpendeBehandling = BehandlingKategori.NASJONAL, + tilbakefallendeKategori = BehandlingKategori.NASJONAL, ), ) } @@ -375,7 +266,7 @@ class BehandlingUtilsTest { overstyrtKategori = null, behandlingType = BehandlingType.REVURDERING, behandlingÅrsak = BehandlingÅrsak.NYE_OPPLYSNINGER, - kategoriFraLøpendeBehandling = BehandlingKategori.EØS, + tilbakefallendeKategori = BehandlingKategori.EØS, ), ) } @@ -388,7 +279,7 @@ class BehandlingUtilsTest { overstyrtKategori = null, behandlingType = BehandlingType.REVURDERING, behandlingÅrsak = BehandlingÅrsak.NYE_OPPLYSNINGER, - kategoriFraLøpendeBehandling = BehandlingKategori.NASJONAL, + tilbakefallendeKategori = BehandlingKategori.NASJONAL, ), ) } diff --git a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaServiceTest.kt b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaServiceTest.kt index 6125cc5aaed..e8d6ea17dc0 100644 --- a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaServiceTest.kt +++ b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaServiceTest.kt @@ -1,41 +1,49 @@ package no.nav.familie.ba.sak.kjerne.behandling.behandlingstema -import io.mockk.MockK -import io.mockk.clearAllMocks import io.mockk.every +import io.mockk.just import io.mockk.mockk +import io.mockk.runs +import io.mockk.slot +import io.mockk.verify +import no.nav.familie.ba.sak.TestClockProvider +import no.nav.familie.ba.sak.common.FunksjonellFeil import no.nav.familie.ba.sak.common.defaultFagsak +import no.nav.familie.ba.sak.common.lagAndelTilkjentYtelse import no.nav.familie.ba.sak.common.lagBehandling -import no.nav.familie.ba.sak.common.lagPersonResultaterForSøkerOgToBarn -import no.nav.familie.ba.sak.common.lagTestPersonopplysningGrunnlag +import no.nav.familie.ba.sak.common.lagFagsak +import no.nav.familie.ba.sak.common.lagPersonEnkel +import no.nav.familie.ba.sak.common.lagPersonResultat import no.nav.familie.ba.sak.common.lagVilkårResultat import no.nav.familie.ba.sak.common.lagVilkårsvurdering import no.nav.familie.ba.sak.common.randomAktør -import no.nav.familie.ba.sak.common.randomFnr -import no.nav.familie.ba.sak.common.tilPersonEnkelSøkerOgBarn -import no.nav.familie.ba.sak.config.tilAktør import no.nav.familie.ba.sak.integrasjoner.oppgave.OppgaveService import no.nav.familie.ba.sak.kjerne.autovedtak.fødselshendelse.Resultat import no.nav.familie.ba.sak.kjerne.behandling.BehandlingHentOgPersisterService +import no.nav.familie.ba.sak.kjerne.behandling.domene.Behandling import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingKategori import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingUnderkategori import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelseRepository +import no.nav.familie.ba.sak.kjerne.beregning.domene.YtelseType import no.nav.familie.ba.sak.kjerne.eøs.felles.BehandlingId import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingTidslinjeService import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingTidslinjer +import no.nav.familie.ba.sak.kjerne.grunnlag.personopplysninger.PersonType import no.nav.familie.ba.sak.kjerne.logg.LoggService import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.PersonResultat import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Regelverk import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Vilkår -import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Vilkårsvurdering import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.VilkårsvurderingRepository -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.BeforeAll +import no.nav.familie.kontrakter.felles.Behandlingstema +import no.nav.familie.kontrakter.felles.oppgave.Behandlingstype +import no.nav.familie.kontrakter.felles.oppgave.Oppgave +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Nested import org.junit.jupiter.api.Test -import org.junit.jupiter.api.TestInstance +import org.junit.jupiter.api.assertThrows import java.time.LocalDate +import java.time.YearMonth -@TestInstance(TestInstance.Lifecycle.PER_CLASS) class BehandlingstemaServiceTest { private val behandlingHentOgPersisterService = mockk() private val andelTilkjentYtelseRepository = mockk() @@ -44,7 +52,9 @@ class BehandlingstemaServiceTest { private val tidslinjeService = mockk() private val vilkårsvurderingRepository = mockk() - val behandlingstemaService = + private val dagensDato = LocalDate.of(2024, 10, 1) + + private val behandlingstemaService = BehandlingstemaService( behandlingHentOgPersisterService = behandlingHentOgPersisterService, andelTilkjentYtelseRepository = andelTilkjentYtelseRepository, @@ -52,212 +62,1272 @@ class BehandlingstemaServiceTest { oppgaveService = oppgaveService, vilkårsvurderingTidslinjeService = tidslinjeService, vilkårsvurderingRepository = vilkårsvurderingRepository, + clockProvider = TestClockProvider.lagClockProviderMedFastTidspunkt(dagensDato), ) - val defaultFagsak = defaultFagsak() - val defaultBehandling = lagBehandling(defaultFagsak) - @BeforeAll - fun init() { - clearAllMocks() + private val fagsak = defaultFagsak() + private val behandling = lagBehandling(fagsak = fagsak, id = 0L) + + @Nested + inner class OppdaterBehandlingstemaFraRegistrereSøknadStegTest { + @Test + fun `skal ikke oppdatere behandlingstema hvis behandling skal oppdates automatisk`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + skalBehandlesAutomatisk = true, + ) + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg( + behandling = behandling, + nyUnderkategori = BehandlingUnderkategori.ORDINÆR, + ) + + // Assert + assertThat(oppdatertBehandling).isEqualTo(behandling) + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.NASJONAL) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } + + @Test + fun `skal oppdatere behandlingstema for registrering av søknad når det er en endring`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + ) + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.UtvidetBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg( + behandling = behandling, + nyUnderkategori = BehandlingUnderkategori.ORDINÆR, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + assertThat(patchedOppgave?.behandlingstema).isEqualTo(Behandlingstema.OrdinærBarnetrygd.value) + assertThat(patchedOppgave?.behandlingstype).isEqualTo(Behandlingstype.NASJONAL.value) + assertThat(oppdatertBehandling.kategori).isEqualTo(behandling.kategori) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } - MockK.useImpl { } - every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(defaultFagsak.id) } returns defaultBehandling + @Test + fun `skal oppdatere behandlingstema for registrering av søknad når ikke det er en endring`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + ) + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg( + behandling = behandling, + nyUnderkategori = behandling.underkategori, + ) + + // Assert + verify(exactly = 0) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 0) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + assertThat(oppdatertBehandling.kategori).isEqualTo(behandling.kategori) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } + + @Test + fun `skal oppdatere behandlingstema i database men ikke patch oppgave om det allerede er i synk`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + ) + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.OrdinærBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg( + behandling = behandling, + nyUnderkategori = BehandlingUnderkategori.ORDINÆR, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + assertThat(patchedOppgave).isNull() + assertThat(oppdatertBehandling.kategori).isEqualTo(behandling.kategori) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } } - @Test - fun `Skal utlede EØS dersom minst ett vilkår i har blitt behandlet i inneværende behandling`() { - val barn = randomAktør() - val vilkårsvurdering = - Vilkårsvurdering( - behandling = defaultBehandling, - ) - val personResultat = - PersonResultat( - vilkårsvurdering = vilkårsvurdering, - aktør = barn, - vilkårResultater = - mutableSetOf( - lagVilkårResultat( - vilkår = Vilkår.BOSATT_I_RIKET, - vilkårRegelverk = Regelverk.NASJONALE_REGLER, - behandlingId = defaultBehandling.id, - ), - lagVilkårResultat( - vilkår = Vilkår.BOSATT_I_RIKET, - vilkårRegelverk = Regelverk.EØS_FORORDNINGEN, - behandlingId = defaultBehandling.id, - ), - ), - ) - vilkårsvurdering.personResultater = setOf(personResultat) - every { vilkårsvurderingRepository.findByBehandlingAndAktiv(defaultBehandling.id) } returns vilkårsvurdering + @Nested + inner class OppdaterSaksbehandletBehandlingstemaTest { + @Test + fun `skal kaste exception om behandlingen skal behandles automatisk men saksbehandler prøver å oppdatere behandlingestema`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + skalBehandlesAutomatisk = true, + ) + + // Act & assert + val exception = + assertThrows { + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( + behandling, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + } + assertThat(exception.message).isEqualTo("Kan ikke oppdatere behandlingstema manuelt på behandlinger som skal behandles automatisk.") + } + + @Test + fun `skal oppdatere både saksbehandlet kategori og underkategori på behandling`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.ORDINÆR, + ) + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.OrdinærBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + every { loggService.opprettEndretBehandlingstema(any(), any(), any(), any(), any()) } just runs + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( + behandling = behandling, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + verify(exactly = 1) { + loggService.opprettEndretBehandlingstema( + behandling = oppdatertBehandling, + forrigeKategori = BehandlingKategori.NASJONAL, + forrigeUnderkategori = BehandlingUnderkategori.ORDINÆR, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + } + assertThat(patchedOppgave?.behandlingstema).isEqualTo(Behandlingstema.UtvidetBarnetrygd.value) + assertThat(patchedOppgave?.behandlingstype).isEqualTo(Behandlingstype.EØS.value) + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.EØS) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } + + @Test + fun `skal oppdatere kun saksbehandlet kategori behandling`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + ) + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.UtvidetBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + every { loggService.opprettEndretBehandlingstema(any(), any(), any(), any(), any()) } just runs + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( + behandling = behandling, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + verify(exactly = 1) { + loggService.opprettEndretBehandlingstema( + behandling = oppdatertBehandling, + forrigeKategori = BehandlingKategori.NASJONAL, + forrigeUnderkategori = BehandlingUnderkategori.UTVIDET, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + } + assertThat(patchedOppgave?.behandlingstema).isEqualTo(Behandlingstema.UtvidetBarnetrygd.value) + assertThat(patchedOppgave?.behandlingstype).isEqualTo(Behandlingstype.EØS.value) + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.EØS) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } + + @Test + fun `skal oppdatere kun saksbehandlet underkategori behandling`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + ) + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.UtvidetBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + every { loggService.opprettEndretBehandlingstema(any(), any(), any(), any(), any()) } just runs + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( + behandling = behandling, + nyKategori = BehandlingKategori.NASJONAL, + nyUnderkategori = BehandlingUnderkategori.ORDINÆR, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + verify(exactly = 1) { + loggService.opprettEndretBehandlingstema( + behandling = oppdatertBehandling, + forrigeKategori = BehandlingKategori.NASJONAL, + forrigeUnderkategori = BehandlingUnderkategori.UTVIDET, + nyKategori = BehandlingKategori.NASJONAL, + nyUnderkategori = BehandlingUnderkategori.ORDINÆR, + ) + } + assertThat(patchedOppgave?.behandlingstema).isEqualTo(Behandlingstema.OrdinærBarnetrygd.value) + assertThat(patchedOppgave?.behandlingstype).isEqualTo(Behandlingstype.NASJONAL.value) + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.NASJONAL) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } - val kategori = behandlingstemaService.hentKategoriFraInneværendeBehandling(defaultFagsak.id) + @Test + fun `skal ikke oppdatere kategori eller underkategori om de er uendret fra det some allerede finnes i databasen`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.UTVIDET, + ) - assertEquals(BehandlingKategori.EØS, kategori) + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.UtvidetBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + every { loggService.opprettEndretBehandlingstema(any(), any(), any(), any(), any()) } just runs + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( + behandling = behandling, + nyKategori = BehandlingKategori.NASJONAL, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + + // Assert + verify(exactly = 0) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 0) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + verify(exactly = 0) { + loggService.opprettEndretBehandlingstema( + behandling = any(), + forrigeKategori = any(), + forrigeUnderkategori = any(), + nyKategori = any(), + nyUnderkategori = any(), + ) + } + assertThat(patchedOppgave).isNull() + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.NASJONAL) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } + + @Test + fun `skal oppdatere patche oppgave om det allerde er i synk med databaseendringen`() { + // Arrange + val behandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.ORDINÆR, + ) + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.UtvidetBarnetrygd.value, + behandlingstype = Behandlingstype.EØS.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(behandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + every { loggService.opprettEndretBehandlingstema(any(), any(), any(), any(), any()) } just runs + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( + behandling = behandling, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + verify(exactly = 1) { + loggService.opprettEndretBehandlingstema( + behandling = oppdatertBehandling, + forrigeKategori = BehandlingKategori.NASJONAL, + forrigeUnderkategori = BehandlingUnderkategori.ORDINÆR, + nyKategori = BehandlingKategori.EØS, + nyUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + } + assertThat(patchedOppgave).isNull() + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.EØS) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } } - @Test - fun `Skal utlede NASJONAL dersom EØS vilkåret ble behandlet i annen behandling`() { - val barn = randomAktør() - val vilkårsvurdering = - Vilkårsvurdering( - behandling = defaultBehandling, - ) - val personResultat = - PersonResultat( - vilkårsvurdering = vilkårsvurdering, - aktør = barn, - vilkårResultater = - mutableSetOf( - lagVilkårResultat( - vilkår = Vilkår.BOSATT_I_RIKET, - vilkårRegelverk = Regelverk.NASJONALE_REGLER, - behandlingId = defaultBehandling.id, - ), - lagVilkårResultat( - vilkår = Vilkår.BOSATT_I_RIKET, - vilkårRegelverk = Regelverk.EØS_FORORDNINGEN, - behandlingId = 0L, - ), - ), - ) - vilkårsvurdering.personResultater = setOf(personResultat) - every { vilkårsvurderingRepository.findByBehandlingAndAktiv(defaultBehandling.id) } returns vilkårsvurdering + @Nested + inner class OppdaterBehandlingstemaForVilkårTest { + @Test + fun `skal ikke oppdatere kategori og underkategori om behandling skal behandles automatisk`() { + // Arrange + val aktivBehandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.ORDINÆR, + skalBehandlesAutomatisk = true, + ) + + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaForVilkår( + behandling = aktivBehandling, + ) + + // Assert + verify(exactly = 0) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 0) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + assertThat(oppdatertBehandling).isEqualTo(aktivBehandling) + } + + @Test + fun `skal sette overstyr underkategori`() { + // Arrange + val aktivBehandling = + lagBehandling( + behandlingKategori = BehandlingKategori.NASJONAL, + underkategori = BehandlingUnderkategori.ORDINÆR, + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns null + every { vilkårsvurderingRepository.findByBehandlingAndAktiv(aktivBehandling.id) } returns null + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.OrdinærBarnetrygd.value, + behandlingstype = Behandlingstype.NASJONAL.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(aktivBehandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(aktivBehandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaForVilkår( + behandling = aktivBehandling, + overstyrtUnderkategori = BehandlingUnderkategori.UTVIDET, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + + assertThat(patchedOppgave?.behandlingstema).isEqualTo(Behandlingstema.UtvidetBarnetrygd.value) + assertThat(patchedOppgave?.behandlingstype).isEqualTo(Behandlingstype.NASJONAL.value) + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.NASJONAL) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } - val kategori = behandlingstemaService.hentKategoriFraInneværendeBehandling(defaultFagsak.id) + @Test + fun `skal oppdatere behandling ved utledet kategori og underkategori`() { + // Arrange + val aktivBehandling = + lagBehandling( + behandlingKategori = BehandlingKategori.EØS, + underkategori = BehandlingUnderkategori.UTVIDET, + ) - assertEquals(BehandlingKategori.NASJONAL, kategori) + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns null + every { vilkårsvurderingRepository.findByBehandlingAndAktiv(aktivBehandling.id) } returns null + + val oppgave = + Oppgave( + behandlingstema = Behandlingstema.BarnetrygdEØS.value, + behandlingstype = Behandlingstype.EØS.value, + ) + val patchOppgaveCallback = slot<(Oppgave) -> Oppgave>() + var patchedOppgave: Oppgave? = null + + every { behandlingHentOgPersisterService.lagreEllerOppdater(aktivBehandling) } returnsArgument 0 + every { oppgaveService.patchOppgaverForBehandling(eq(aktivBehandling), capture(patchOppgaveCallback)) } answers { + patchedOppgave = patchOppgaveCallback.captured.invoke(oppgave) + } + // Act + val oppdatertBehandling = + behandlingstemaService.oppdaterBehandlingstemaForVilkår( + behandling = aktivBehandling, + ) + + // Assert + verify(exactly = 1) { behandlingHentOgPersisterService.lagreEllerOppdater(any()) } + verify(exactly = 1) { oppgaveService.patchOppgaverForBehandling(any(), any()) } + + assertThat(patchedOppgave?.behandlingstema).isEqualTo(Behandlingstema.OrdinærBarnetrygd.value) + assertThat(patchedOppgave?.behandlingstype).isEqualTo(Behandlingstype.NASJONAL.value) + assertThat(oppdatertBehandling.kategori).isEqualTo(BehandlingKategori.NASJONAL) + assertThat(oppdatertBehandling.underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } } - @Test - fun `Skal utlede UTVIDET dersom minst ett vilkår i har blitt behandlet i inneværende behandling`() { - val vilkårsvurdering = - Vilkårsvurdering( - behandling = defaultBehandling, - ) - val personResultat = - PersonResultat( - vilkårsvurdering = vilkårsvurdering, - aktør = defaultFagsak.aktør, - vilkårResultater = - mutableSetOf( - lagVilkårResultat( - vilkår = Vilkår.UTVIDET_BARNETRYGD, - behandlingId = defaultBehandling.id, - ), - lagVilkårResultat( - vilkår = Vilkår.UTVIDET_BARNETRYGD, - behandlingId = defaultBehandling.id, - ), - ), - ) - vilkårsvurdering.personResultater = setOf(personResultat) - every { vilkårsvurderingRepository.findByBehandlingAndAktiv(defaultBehandling.id) } returns vilkårsvurdering + @Nested + inner class FinnBehandlingKategoriTest { + @Test + fun `skal returnere NASJONAL når hverken aktiv eller siste vedtatte behandling finnes`() { + // Arrange + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns null + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Assert + assertThat(kategori).isEqualTo(BehandlingKategori.NASJONAL) + } + + @Test + fun `skal returnere siste vedtatt behandling sin kategori når det ikke finnes en aktiv behandling men en siste vedtatt behandling finnes`() { + // Arrange + val sisteVedtatteBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns null + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns sisteVedtatteBehandling + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Assert + assertThat(kategori).isEqualTo(BehandlingKategori.EØS) + } + + @Test + fun `skal returnere NASJONAL når ingen tidslinje blir funnet for vilkårsvurderingen til den aktive behandlingen og den siste vedtatte behandlingen finnes ikke`() { + // Arrange + val aktivBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns null + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Assert + assertThat(kategori).isEqualTo(BehandlingKategori.NASJONAL) + } + + @Test + fun `skal returnere kategorien til den siste vedtatte behandlingen når ingen tidslinje blir funnet for vilkårsvurderingen til den aktive behandlingen men den siste vedtatte behandlingen finnes`() { + // Arrange + val aktivBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.NASJONAL) + val sisteVedtatteBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) - val underkategori = behandlingstemaService.hentUnderkategoriFraInneværendeBehandling(defaultFagsak.id) + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns sisteVedtatteBehandling + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns null - assertEquals(BehandlingUnderkategori.UTVIDET, underkategori) + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Assert + assertThat(kategori).isEqualTo(BehandlingKategori.EØS) + } + + @Test + fun `skal utlede kategori EØS et barn har en løpende EØS periode`() { + // Arrange + val stønadFom = dagensDato.minusMonths(1) + val stønadTom = dagensDato.plusYears(2) + + val søker = lagPersonEnkel(personType = PersonType.SØKER, aktør = randomAktør()) + val barn1 = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + val barn2 = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + + val fagsak = lagFagsak(aktør = søker.aktør) + val aktivBehandling = lagBehandling(fagsak = fagsak) + + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = aktivBehandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = søker.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.SØKER, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn1.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { if (it in listOf(Vilkår.BOR_MED_SØKER, Vilkår.BOSATT_I_RIKET, Vilkår.LOVLIG_OPPHOLD)) Regelverk.EØS_FORORDNINGEN else null }, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn2.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { if (it in listOf(Vilkår.BOR_MED_SØKER, Vilkår.BOSATT_I_RIKET, Vilkår.LOVLIG_OPPHOLD)) Regelverk.NASJONALE_REGLER else null }, + ) + }, + ), + ) + }, + ) + + val vilkårsvurderingTidslinjer = + VilkårsvurderingTidslinjer( + vilkårsvurdering = vilkårsvurdering, + søkerOgBarn = listOf(søker, barn1, barn2), + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns vilkårsvurderingTidslinjer + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Assert + assertThat(kategori).isEqualTo(BehandlingKategori.EØS) + } + + @Test + fun `skal utlede kategori NASJONAL når et barn har en løpenede nasjonal periode`() { + // Arrange + val stønadFom = dagensDato.minusMonths(1) + val stønadTom = dagensDato.plusYears(2) + + val søker = lagPersonEnkel(personType = PersonType.SØKER, aktør = randomAktør()) + val barn = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + + val fagsak = lagFagsak(aktør = søker.aktør) + val aktivBehandling = lagBehandling(fagsak = fagsak) + + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = aktivBehandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = søker.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.SØKER, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { if (it in listOf(Vilkår.BOR_MED_SØKER, Vilkår.BOSATT_I_RIKET, Vilkår.LOVLIG_OPPHOLD)) Regelverk.NASJONALE_REGLER else null }, + ) + }, + ), + ) + }, + ) + + val vilkårsvurderingTidslinjer = + VilkårsvurderingTidslinjer( + vilkårsvurdering = vilkårsvurdering, + søkerOgBarn = listOf(søker, barn), + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns vilkårsvurderingTidslinjer + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Assert + assertThat(kategori).isEqualTo(BehandlingKategori.NASJONAL) + } + + @Test + fun `skal utlede kategorien til siste vedtatte behandling når det ikke finnes en løpende NASJONAL eller løpende EØS periode på barnas vilkårsvurderingtidslinje for den aktive behandling men den siste vedtatte behandling finnes`() { + // Arrange + val stønadFom = dagensDato.minusMonths(3) + val stønadTom = dagensDato.minusMonths(2) + + val søker = lagPersonEnkel(personType = PersonType.SØKER, aktør = randomAktør()) + val barn1 = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + val barn2 = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + + val fagsak = lagFagsak(aktør = søker.aktør) + val aktivBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) + val sisteVedtatteBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) + + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = aktivBehandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = søker.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.SØKER, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn1.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { null }, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn2.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { null }, + ) + }, + ), + ) + }, + ) + + val vilkårsvurderingTidslinjer = + VilkårsvurderingTidslinjer( + vilkårsvurdering = vilkårsvurdering, + søkerOgBarn = listOf(søker, barn1, barn2), + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns sisteVedtatteBehandling + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns vilkårsvurderingTidslinjer + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Act + assertThat(kategori).isEqualTo(BehandlingKategori.EØS) + } + + @Test + fun `skal utlede kategori NASJONAL når det ikke finnes en løpende NASJONAL eller løpende EØS periode på barnas vilkårsvurderingtidslinje for den aktive behandlingen og siste vedtatte behandling finnes ikke`() { + // Arrange + val stønadFom = dagensDato.minusMonths(3) + val stønadTom = dagensDato.minusMonths(2) + + val søker = lagPersonEnkel(personType = PersonType.SØKER, aktør = randomAktør()) + val barn1 = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + val barn2 = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = stønadFom) + + val fagsak = lagFagsak(aktør = søker.aktør) + val aktivBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) + + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = aktivBehandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = søker.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.SØKER, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn1.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { null }, + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn2.aktør, + lagVilkårResultater = { personResultat -> + lagAlleVilkårResultater( + behandling = aktivBehandling, + personType = PersonType.BARN, + personResultat = personResultat, + stønadFom = stønadFom, + stønadTom = stønadTom, + vurderesEtterFn = { null }, + ) + }, + ), + ) + }, + ) + + val vilkårsvurderingTidslinjer = + VilkårsvurderingTidslinjer( + vilkårsvurdering = vilkårsvurdering, + søkerOgBarn = listOf(søker, barn1, barn2), + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns vilkårsvurderingTidslinjer + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Act + assertThat(kategori).isEqualTo(BehandlingKategori.NASJONAL) + } + + @Test + fun `skal utlede kategori NASJONAl`() { + // Arrange + val søker = lagPersonEnkel(personType = PersonType.SØKER, aktør = randomAktør(), fødselsdato = LocalDate.of(1983, 6, 22)) + val barn = lagPersonEnkel(personType = PersonType.BARN, aktør = randomAktør(), fødselsdato = LocalDate.of(2022, 11, 15)) + + val fagsak = lagFagsak(aktør = søker.aktør) + val aktivBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.NASJONAL) + val sisteVedtatteBehandling = lagBehandling(fagsak = fagsak, behandlingKategori = BehandlingKategori.EØS) + + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = aktivBehandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = søker.aktør, + lagVilkårResultater = { personResultat -> + setOf( + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 1, 15), + periodeTom = LocalDate.of(2024, 8, 31), + vurderesEtter = Regelverk.EØS_FORORDNINGEN, + vilkårType = Vilkår.BOSATT_I_RIKET, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2024, 9, 1), + periodeTom = null, + vurderesEtter = Regelverk.NASJONALE_REGLER, + vilkårType = Vilkår.BOSATT_I_RIKET, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 1, 15), + periodeTom = LocalDate.of(2024, 8, 31), + vurderesEtter = Regelverk.EØS_FORORDNINGEN, + vilkårType = Vilkår.LOVLIG_OPPHOLD, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2024, 9, 1), + periodeTom = null, + vurderesEtter = Regelverk.NASJONALE_REGLER, + vilkårType = Vilkår.LOVLIG_OPPHOLD, + ), + ) + }, + ), + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = barn.aktør, + lagVilkårResultater = { personResultat -> + setOf( + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 11, 15), + periodeTom = LocalDate.of(2024, 8, 31), + vurderesEtter = Regelverk.EØS_FORORDNINGEN, + vilkårType = Vilkår.BOSATT_I_RIKET, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2024, 9, 1), + periodeTom = null, + vurderesEtter = Regelverk.NASJONALE_REGLER, + vilkårType = Vilkår.BOSATT_I_RIKET, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 11, 15), + periodeTom = LocalDate.of(2024, 8, 31), + vurderesEtter = Regelverk.EØS_FORORDNINGEN, + vilkårType = Vilkår.LOVLIG_OPPHOLD, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2024, 9, 1), + periodeTom = null, + vurderesEtter = Regelverk.NASJONALE_REGLER, + vilkårType = Vilkår.LOVLIG_OPPHOLD, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 11, 15), + periodeTom = LocalDate.of(2024, 8, 31), + vurderesEtter = Regelverk.EØS_FORORDNINGEN, + vilkårType = Vilkår.BOR_MED_SØKER, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2024, 9, 1), + periodeTom = null, + vurderesEtter = Regelverk.NASJONALE_REGLER, + vilkårType = Vilkår.BOR_MED_SØKER, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 11, 15), + periodeTom = LocalDate.of(2040, 11, 14), + vurderesEtter = null, + vilkårType = Vilkår.UNDER_18_ÅR, + ), + lagVilkårResultat( + personResultat = personResultat, + resultat = Resultat.OPPFYLT, + periodeFom = LocalDate.of(2022, 11, 15), + periodeTom = null, + vurderesEtter = null, + vilkårType = Vilkår.GIFT_PARTNERSKAP, + ), + ) + }, + ), + ) + }, + ) + + val vilkårsvurderingTidslinjer = + VilkårsvurderingTidslinjer( + vilkårsvurdering = vilkårsvurdering, + søkerOgBarn = listOf(søker, barn), + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns aktivBehandling + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns sisteVedtatteBehandling + every { tidslinjeService.hentTidslinjer(BehandlingId(aktivBehandling.id)) } returns vilkårsvurderingTidslinjer + + // Act + val kategori = behandlingstemaService.finnBehandlingKategori(fagsak.id) + + // Act + assertThat(kategori).isEqualTo(BehandlingKategori.NASJONAL) + } + + private fun lagAlleVilkårResultater( + behandling: Behandling, + personType: PersonType, + personResultat: PersonResultat, + stønadFom: LocalDate, + stønadTom: LocalDate, + vurderesEtterFn: (vilkår: Vilkår) -> Regelverk? = { vilkår -> personResultat.let { vilkår.defaultRegelverk(it.vilkårsvurdering.behandling.kategori) } }, + ) = Vilkår + .hentVilkårFor( + personType = personType, + fagsakType = behandling.fagsak.type, + behandlingUnderkategori = behandling.underkategori, + ).map { vilkår -> + lagVilkårResultat( + personResultat = personResultat, + periodeFom = stønadFom, + periodeTom = stønadTom, + vilkårType = vilkår, + resultat = Resultat.OPPFYLT, + behandlingId = behandling.id, + vurderesEtter = vurderesEtterFn(vilkår), + ) + }.toSet() } - @Test - fun `Skal utlede ORDINÆR dersom UTVIDET vilkåret ble behandlet i annen behandling`() { - val barn = randomAktør() - val vilkårsvurdering = - Vilkårsvurdering( - behandling = defaultBehandling, - ) - val personResultat = - PersonResultat( - vilkårsvurdering = vilkårsvurdering, - aktør = barn, - vilkårResultater = - mutableSetOf( - lagVilkårResultat( - vilkår = Vilkår.UTVIDET_BARNETRYGD, - vilkårRegelverk = Regelverk.NASJONALE_REGLER, - behandlingId = 0L, - ), + @Nested + inner class FinnLøpendeUnderkategoriFraForrigeVedtatteBehandlingTest { + @Test + fun `skal returnere null om ingen vedtatt behandling for fagsaken blir funnet`() { + // Arrange + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns null + + // Act + val underkategori = behandlingstemaService.finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(fagsak.id) + + // Assert + assertThat(underkategori).isNull() + } + + @Test + fun `skal returnere UTVIDET om det finnes en andel tilkjent ytelse som er løpende og er av ytelsestype UTVIDET_BARNETRYGD`() { + // Arrange + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns behandling + every { andelTilkjentYtelseRepository.finnAndelerTilkjentYtelseForBehandling(behandling.id) } returns + listOf( + lagAndelTilkjentYtelse( + fom = YearMonth.now().minusMonths(1), + tom = YearMonth.now().plusMonths(1), + ytelseType = YtelseType.UTVIDET_BARNETRYGD, ), - ) - vilkårsvurdering.personResultater = setOf(personResultat) - every { vilkårsvurderingRepository.findByBehandlingAndAktiv(defaultBehandling.id) } returns vilkårsvurdering + ) + // Act + val underkategori = behandlingstemaService.finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(fagsak.id) - val underkategori = behandlingstemaService.hentUnderkategoriFraInneværendeBehandling(defaultFagsak.id) + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } - assertEquals(BehandlingUnderkategori.ORDINÆR, underkategori) - } + @Test + fun `skal returnere ORDINÆR om det finnes en andel tilkjent ytelse som er løpende men ikke av ytelsestype UTVIDET_BARNETRYGD`() { + // Arrange + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns behandling + every { andelTilkjentYtelseRepository.finnAndelerTilkjentYtelseForBehandling(behandling.id) } returns + listOf( + lagAndelTilkjentYtelse( + fom = YearMonth.now().minusMonths(1), + tom = YearMonth.now().plusMonths(1), + ytelseType = YtelseType.ORDINÆR_BARNETRYGD, + ), + ) + // Act + val underkategori = behandlingstemaService.finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(fagsak.id) - @Test - fun `skal hente løpende kategori til NASJONAL når siste behandling er NASJONAL og har løpende utbetaling`() { - val søkerFnr = randomFnr() - val barnFnr = listOf(randomFnr()) - every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(defaultFagsak.id) } returns defaultBehandling - every { tidslinjeService.hentTidslinjer(BehandlingId(defaultBehandling.id)) } returns - VilkårsvurderingTidslinjer( - vilkårsvurdering = lagVilkårsvurdering(tilAktør(søkerFnr), defaultBehandling, Resultat.OPPFYLT), - søkerOgBarn = - lagTestPersonopplysningGrunnlag(defaultBehandling.id, randomFnr(), barnFnr) - .tilPersonEnkelSøkerOgBarn(), - ) - assertEquals(BehandlingKategori.NASJONAL, behandlingstemaService.hentLøpendeKategori(defaultFagsak.id)) - } + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } + + @Test + fun `skal returnere ORDINÆR om det finnes en andel tilkjent ytelse som ikke er løpende men er av ytelsestype UTVIDET_BARNETRYGD`() { + // Arrange + every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(fagsak.id) } returns behandling + every { andelTilkjentYtelseRepository.finnAndelerTilkjentYtelseForBehandling(behandling.id) } returns + listOf( + lagAndelTilkjentYtelse( + fom = YearMonth.now().minusMonths(2), + tom = YearMonth.now().minusMonths(1), + ytelseType = YtelseType.ORDINÆR_BARNETRYGD, + ), + ) + // Act + val underkategori = behandlingstemaService.finnLøpendeUnderkategoriFraForrigeVedtatteBehandling(fagsak.id) - @Test - fun `skal hente løpende kategori til EØS når siste behandling er EØS og har løpende utbetaling`() { - val søkerFnr = randomFnr() - val barnFnr = randomFnr() - val barn2Fnr = randomFnr() - val barnaFnr = listOf(barnFnr, barn2Fnr) - val behandlingMedEøsRegelverk = defaultBehandling.copy(kategori = BehandlingKategori.EØS) - every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(defaultFagsak.id) } returns - behandlingMedEøsRegelverk - val vilkårsvurdering = Vilkårsvurdering(behandling = behandlingMedEøsRegelverk) - vilkårsvurdering.personResultater = - lagPersonResultaterForSøkerOgToBarn( - vilkårsvurdering, - tilAktør(søkerFnr), - tilAktør(barnFnr), - tilAktør(barn2Fnr), - LocalDate.now().minusMonths(1), - LocalDate.now().plusYears(2), - ) - every { tidslinjeService.hentTidslinjer(BehandlingId(defaultBehandling.id)) } returns - VilkårsvurderingTidslinjer( - vilkårsvurdering = vilkårsvurdering, - søkerOgBarn = - lagTestPersonopplysningGrunnlag(defaultBehandling.id, søkerFnr, barnaFnr) - .tilPersonEnkelSøkerOgBarn(), - ) - assertEquals(BehandlingKategori.EØS, behandlingstemaService.hentLøpendeKategori(defaultFagsak.id)) + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } } - @Test - fun `skal hente løpende kategori til NASJONAL når siste behandling er EØS opphørt`() { - val søkerFnr = randomFnr() - val barnFnr = randomFnr() - val barn2Fnr = randomFnr() - val barnaFnr = listOf(barnFnr, barn2Fnr) - val behandlingMedEøsRegelverk = defaultBehandling.copy(kategori = BehandlingKategori.EØS) - every { behandlingHentOgPersisterService.hentSisteBehandlingSomErVedtatt(defaultFagsak.id) } returns - behandlingMedEøsRegelverk - val vilkårsvurdering = Vilkårsvurdering(behandling = behandlingMedEøsRegelverk) - vilkårsvurdering.personResultater = - lagPersonResultaterForSøkerOgToBarn( - vilkårsvurdering, - tilAktør(søkerFnr), - tilAktør(barnFnr), - tilAktør(barn2Fnr), - LocalDate.now().minusMonths(3), - LocalDate.now().minusMonths(2), - ) - every { tidslinjeService.hentTidslinjer(BehandlingId(defaultBehandling.id)) } returns - VilkårsvurderingTidslinjer( - vilkårsvurdering = vilkårsvurdering, - søkerOgBarn = - lagTestPersonopplysningGrunnlag(defaultBehandling.id, søkerFnr, barnaFnr) - .tilPersonEnkelSøkerOgBarn(), - ) - assertEquals(BehandlingKategori.NASJONAL, behandlingstemaService.hentLøpendeKategori(defaultFagsak.id)) + @Nested + inner class FinnUnderkategoriFraAktivBehandlingTest { + @Test + fun `skal returnere ORDINÆR om ingen aktiv og åpen behandling blir funnet for fagsak`() { + // Arrange + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns null + + // Act + val underkategori = behandlingstemaService.finnUnderkategoriFraAktivBehandling(fagsak.id) + + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } + + @Test + fun `skal returnere ORDINÆR om ingen vilkårsvurdering blir funnet for behandlingen`() { + // Arrange + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns behandling + every { vilkårsvurderingRepository.findByBehandlingAndAktiv(behandling.id) } returns null + + // Act + val underkategori = behandlingstemaService.finnUnderkategoriFraAktivBehandling(fagsak.id) + + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } + + @Test + fun `Skal utlede UTVIDET dersom minst ett vilkår i har blitt behandlet i inneværende behandling`() { + // Arrange + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = behandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = fagsak.aktør, + lagVilkårResultater = { + setOf( + lagVilkårResultat( + personResultat = it, + behandlingId = behandling.id, + vilkårType = Vilkår.UTVIDET_BARNETRYGD, + periodeFom = dagensDato.minusMonths(1), + periodeTom = dagensDato, + ), + lagVilkårResultat( + personResultat = it, + behandlingId = behandling.id, + vilkårType = Vilkår.BOSATT_I_RIKET, + periodeFom = dagensDato.plusDays(1), + periodeTom = dagensDato.plusMonths(2), + ), + ) + }, + ), + ) + }, + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns behandling + every { vilkårsvurderingRepository.findByBehandlingAndAktiv(behandling.id) } returns vilkårsvurdering + + // Act + val underkategori = behandlingstemaService.finnUnderkategoriFraAktivBehandling(fagsak.id) + + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.UTVIDET) + } + + @Test + fun `Skal utlede ORDINÆR dersom ingen utvidet barnetrygd vilkår i har blitt behandlet i inneværende behandling`() { + // Arrange + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = behandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = fagsak.aktør, + lagVilkårResultater = { + setOf( + lagVilkårResultat( + personResultat = it, + behandlingId = behandling.id, + vilkårType = Vilkår.BOR_MED_SØKER, + periodeFom = dagensDato.minusMonths(1), + periodeTom = dagensDato, + ), + ) + }, + ), + ) + }, + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns behandling + every { vilkårsvurderingRepository.findByBehandlingAndAktiv(behandling.id) } returns vilkårsvurdering + + // Act + val underkategori = behandlingstemaService.finnUnderkategoriFraAktivBehandling(fagsak.id) + + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } + + @Test + fun `Skal utlede ORDINÆR dersom UTVIDET vilkåret ble behandlet i annen behandling`() { + // Arrange + val vilkårsvurdering = + lagVilkårsvurdering( + behandling = behandling, + lagPersonResultater = { vilkårsvurdering -> + setOf( + lagPersonResultat( + vilkårsvurdering = vilkårsvurdering, + aktør = fagsak.aktør, + lagVilkårResultater = { + setOf( + lagVilkårResultat( + personResultat = it, + behandlingId = 1337L, + vilkårType = Vilkår.UTVIDET_BARNETRYGD, + vurderesEtter = Regelverk.NASJONALE_REGLER, + periodeFom = dagensDato.minusMonths(1), + periodeTom = dagensDato.plusMonths(1), + ), + ) + }, + ), + ) + }, + ) + + every { behandlingHentOgPersisterService.finnAktivOgÅpenForFagsak(fagsak.id) } returns behandling + every { vilkårsvurderingRepository.findByBehandlingAndAktiv(behandling.id) } returns vilkårsvurdering + + // Act + val underkategori = behandlingstemaService.finnUnderkategoriFraAktivBehandling(fagsak.id) + + // Assert + assertThat(underkategori).isEqualTo(BehandlingUnderkategori.ORDINÆR) + } } } diff --git "a/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knadTest.kt" "b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knadTest.kt" new file mode 100644 index 00000000000..03b577dc543 --- /dev/null +++ "b/src/test/enhetstester/kotlin/no/nav/familie/ba/sak/kjerne/steg/RegistrereS\303\270knadTest.kt" @@ -0,0 +1,145 @@ +package no.nav.familie.ba.sak.kjerne.steg + +import io.mockk.every +import io.mockk.just +import io.mockk.mockk +import io.mockk.runs +import io.mockk.verify +import no.nav.familie.ba.sak.common.lagSøknadDTO +import no.nav.familie.ba.sak.common.lagVedtak +import no.nav.familie.ba.sak.common.randomFnr +import no.nav.familie.ba.sak.ekstern.restDomene.RestRegistrerSøknad +import no.nav.familie.ba.sak.ekstern.restDomene.tilDomene +import no.nav.familie.ba.sak.kjerne.behandling.BehandlingHentOgPersisterService +import no.nav.familie.ba.sak.kjerne.behandling.behandlingstema.BehandlingstemaService +import no.nav.familie.ba.sak.kjerne.behandling.domene.BehandlingUnderkategori +import no.nav.familie.ba.sak.kjerne.grunnlag.personopplysninger.PersongrunnlagService +import no.nav.familie.ba.sak.kjerne.grunnlag.søknad.SøknadGrunnlagService +import no.nav.familie.ba.sak.kjerne.logg.LoggService +import no.nav.familie.ba.sak.kjerne.simulering.lagBehandling +import no.nav.familie.ba.sak.kjerne.vedtak.VedtakService +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Nested +import org.junit.jupiter.api.Test + +class RegistrereSøknadTest { + private val behandlingHentOgPersisterService = mockk() + private val behandlingstemaService = mockk() + private val søknadGrunnlagService = mockk() + private val persongrunnlagService = mockk() + private val loggService = mockk() + private val vedtakService = mockk() + private val tilbakestillBehandlingService = mockk() + + private val registrereSøknad: RegistrereSøknad = + RegistrereSøknad( + behandlingHentOgPersisterService = behandlingHentOgPersisterService, + behandlingstemaService = behandlingstemaService, + søknadGrunnlagService = søknadGrunnlagService, + persongrunnlagService = persongrunnlagService, + loggService = loggService, + vedtakService = vedtakService, + tilbakestillBehandlingService = tilbakestillBehandlingService, + ) + + @Nested + inner class UtførStegOgAngiNesteTest { + @Test + fun `skal registrer søknad uten å oppdatere behandlingstema`() { + // Arrange + val behandling = lagBehandling(underkategori = BehandlingUnderkategori.ORDINÆR) + + val søknadDTO = + lagSøknadDTO( + søkerIdent = randomFnr(), + barnasIdenter = listOf(randomFnr()), + underkategori = BehandlingUnderkategori.ORDINÆR, + ) + + val restRegistrerSøknad = + RestRegistrerSøknad( + søknad = søknadDTO, + bekreftEndringerViaFrontend = false, + ) + + val vedtak = lagVedtak(behandling = behandling) + + every { søknadGrunnlagService.hentAktiv(behandlingId = behandling.id) } returns null + every { loggService.opprettRegistrertSøknadLogg(behandling, false) } just runs + every { søknadGrunnlagService.lagreOgDeaktiverGammel(any()) } returnsArgument 0 + every { behandlingHentOgPersisterService.hentForrigeBehandlingSomErVedtatt(behandling = behandling) } returns null + every { persongrunnlagService.registrerBarnFraSøknad(søknadDTO, behandling, null) } just runs + every { tilbakestillBehandlingService.initierOgSettBehandlingTilVilkårsvurdering(behandling, restRegistrerSøknad.bekreftEndringerViaFrontend) } just runs + every { vedtakService.hentAktivForBehandlingThrows(behandlingId = behandling.id) } returns vedtak + every { vedtakService.oppdater(vedtak) } returnsArgument 0 + + // Act + val stegType = + registrereSøknad.utførStegOgAngiNeste( + behandling = behandling, + data = restRegistrerSøknad, + ) + + // Assert + verify(exactly = 0) { behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg(any(), any()) } + verify(exactly = 1) { loggService.opprettRegistrertSøknadLogg(behandling, false) } + verify(exactly = 1) { søknadGrunnlagService.lagreOgDeaktiverGammel(any()) } + verify(exactly = 1) { persongrunnlagService.registrerBarnFraSøknad(søknadDTO, behandling, null) } + verify(exactly = 1) { tilbakestillBehandlingService.initierOgSettBehandlingTilVilkårsvurdering(behandling, restRegistrerSøknad.bekreftEndringerViaFrontend) } + verify(exactly = 1) { vedtakService.oppdater(vedtak) } + assertThat(stegType).isEqualTo(StegType.VILKÅRSVURDERING) + assertThat(behandling.underkategori).isEqualTo(søknadDTO.underkategori.tilDomene()) + } + + @Test + fun `skal registrer søknad og oppdatere behandlingstema`() { + // Arrange + val behandling = lagBehandling(underkategori = BehandlingUnderkategori.ORDINÆR) + + val søknadDTO = + lagSøknadDTO( + søkerIdent = randomFnr(), + barnasIdenter = listOf(randomFnr()), + underkategori = BehandlingUnderkategori.UTVIDET, + ) + + val restRegistrerSøknad = + RestRegistrerSøknad( + søknad = søknadDTO, + bekreftEndringerViaFrontend = false, + ) + + val vedtak = lagVedtak(behandling = behandling) + + every { behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg(behandling, søknadDTO.underkategori.tilDomene()) } answers { + behandling.underkategori = søknadDTO.underkategori.tilDomene() + behandling + } + every { søknadGrunnlagService.hentAktiv(behandlingId = behandling.id) } returns null + every { loggService.opprettRegistrertSøknadLogg(behandling, false) } just runs + every { søknadGrunnlagService.lagreOgDeaktiverGammel(any()) } returnsArgument 0 + every { behandlingHentOgPersisterService.hentForrigeBehandlingSomErVedtatt(behandling = behandling) } returns null + every { persongrunnlagService.registrerBarnFraSøknad(søknadDTO, behandling, null) } just runs + every { tilbakestillBehandlingService.initierOgSettBehandlingTilVilkårsvurdering(behandling, restRegistrerSøknad.bekreftEndringerViaFrontend) } just runs + every { vedtakService.hentAktivForBehandlingThrows(behandlingId = behandling.id) } returns vedtak + every { vedtakService.oppdater(vedtak) } returnsArgument 0 + + // Act + val stegType = + registrereSøknad.utførStegOgAngiNeste( + behandling = behandling, + data = restRegistrerSøknad, + ) + + // Assert + verify(exactly = 1) { behandlingstemaService.oppdaterBehandlingstemaFraRegistrereSøknadSteg(behandling, søknadDTO.underkategori.tilDomene()) } + verify(exactly = 1) { loggService.opprettRegistrertSøknadLogg(behandling, false) } + verify(exactly = 1) { søknadGrunnlagService.lagreOgDeaktiverGammel(any()) } + verify(exactly = 1) { persongrunnlagService.registrerBarnFraSøknad(søknadDTO, behandling, null) } + verify(exactly = 1) { tilbakestillBehandlingService.initierOgSettBehandlingTilVilkårsvurdering(behandling, restRegistrerSøknad.bekreftEndringerViaFrontend) } + verify(exactly = 1) { vedtakService.oppdater(vedtak) } + assertThat(stegType).isEqualTo(StegType.VILKÅRSVURDERING) + assertThat(behandling.underkategori).isEqualTo(søknadDTO.underkategori.tilDomene()) + } + } +} diff --git a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/CucumberMock.kt b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/CucumberMock.kt index 3b57ab4178e..c473b1f3156 100644 --- a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/CucumberMock.kt +++ b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/CucumberMock.kt @@ -77,12 +77,9 @@ import no.nav.familie.ba.sak.task.StatusFraOppdragTask import no.nav.familie.felles.utbetalingsgenerator.Utbetalingsgenerator import org.slf4j.Logger import org.slf4j.LoggerFactory -import java.time.ZoneId val logger: Logger = LoggerFactory.getLogger("CucumberMock") -private val zoneId = ZoneId.of("Europe/Oslo") - class CucumberMock( dataFraCucumber: VedtaksperioderOgBegrunnelserStepDefinition, nyBehandlingId: Long, @@ -144,6 +141,7 @@ class CucumberMock( oppgaveService = oppgaveService, vilkårsvurderingTidslinjeService = vilkårsvurderingTidslinjeService, vilkårsvurderingRepository = vilkårsvurderingRepository, + clockProvider = clockProvider, ) val småbarnstilleggService = diff --git a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/komponentMocks/MockOppgaveService.kt b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/komponentMocks/MockOppgaveService.kt index 8c28c771ee8..ad0fe49aa43 100644 --- a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/komponentMocks/MockOppgaveService.kt +++ b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/cucumber/mock/komponentMocks/MockOppgaveService.kt @@ -1,11 +1,14 @@ package no.nav.familie.ba.sak.cucumber.mock import io.mockk.every +import io.mockk.just import io.mockk.mockk +import io.mockk.runs import no.nav.familie.ba.sak.integrasjoner.oppgave.OppgaveService fun mockOppgaveService(): OppgaveService { val oppgaveService = mockk() every { oppgaveService.opprettOppgaveForManuellBehandling(any(), any(), any(), any()) } returns "" + every { oppgaveService.patchOppgaverForBehandling(any(), any()) } just runs return oppgaveService } diff --git "a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/verdikjedetester/F\303\270dselshendelseHenleggelseTest.kt" "b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/verdikjedetester/F\303\270dselshendelseHenleggelseTest.kt" index f68bcd831a2..5909d84b004 100644 --- "a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/verdikjedetester/F\303\270dselshendelseHenleggelseTest.kt" +++ "b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/verdikjedetester/F\303\270dselshendelseHenleggelseTest.kt" @@ -477,7 +477,7 @@ class FødselshendelseHenleggelseTest( brevmalService = brevmalService, ) - oppdaterRegelverkTilEøs(behandling) + oppdaterBehandlingOgRegelverkTilEøs(behandling) val revurdering = behandleFødselshendelse( @@ -575,7 +575,7 @@ class FødselshendelseHenleggelseTest( } } - private fun oppdaterRegelverkTilEøs(behandling: Behandling) { + private fun oppdaterBehandlingOgRegelverkTilEøs(behandling: Behandling) { vilkårsvurderingService.hentAktivForBehandling(behandling.id)!!.apply { personResultater.first { !it.erSøkersResultater() }.apply { vilkårResultater.forEach { @@ -585,5 +585,7 @@ class FødselshendelseHenleggelseTest( } vilkårsvurderingService.oppdater(this) } + behandling.kategori = BehandlingKategori.EØS + behandlingHentOgPersisterService.lagreEllerOppdater(behandling) } } diff --git "a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rServiceTest.kt" "b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rServiceTest.kt" index 1275a0d0164..e35b3e3304d 100644 --- "a/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rServiceTest.kt" +++ "b/src/test/integrasjonstester/kotlin/no/nav/familie/ba/sak/kjerne/vilk\303\245rsvurdering/Vilk\303\245rServiceTest.kt" @@ -1334,7 +1334,7 @@ class VilkårServiceTest( } } - behandlingstemaService.oppdaterBehandlingstema( + behandlingstemaService.oppdaterSaksbehandletBehandlingstema( behandling, BehandlingKategori.EØS, BehandlingUnderkategori.ORDINÆR, @@ -1453,7 +1453,7 @@ class VilkårServiceTest( val barnFnr = randomFnr() val fagsak = fagsakService.hentEllerOpprettFagsakForPersonIdent(fnr) - var behandling = + val behandling = behandlingService.opprettBehandling(nyOrdinærBehandling(søkersIdent = fnr, fagsakId = fagsak.id)) val forrigeBehandlingSomErIverksatt =