diff --git a/hendelse/domain/src/main/kotlin/no/nav/su/se/bakover/hendelse/domain/Hendelse.kt b/hendelse/domain/src/main/kotlin/no/nav/su/se/bakover/hendelse/domain/Hendelse.kt index 313a02fe4d..41569b3d57 100644 --- a/hendelse/domain/src/main/kotlin/no/nav/su/se/bakover/hendelse/domain/Hendelse.kt +++ b/hendelse/domain/src/main/kotlin/no/nav/su/se/bakover/hendelse/domain/Hendelse.kt @@ -5,6 +5,7 @@ import java.util.UUID /** * @property hendelseId unikt identifiserer denne hendelsen. + * @property tidligereHendelseId en tidligere hendelse som denne nye hendelsen korrigerer / tillegger / annullerer * @property entitetId Også kalt streamId. knytter et domeneområdet sammen (f.eks sak) * @property versjon rekkefølgen hendelser skjer innenfor [entitetId] * @property hendelsestidspunkt Tidspunktet hendelsen skjedde fra domenet sin side. diff --git a/test-common/src/main/kotlin/tilbakekreving/TilbakekrevingsklientStub.kt b/test-common/src/main/kotlin/tilbakekreving/TilbakekrevingsklientStub.kt index 2d33666379..635ff62148 100644 --- a/test-common/src/main/kotlin/tilbakekreving/TilbakekrevingsklientStub.kt +++ b/test-common/src/main/kotlin/tilbakekreving/TilbakekrevingsklientStub.kt @@ -4,7 +4,9 @@ import arrow.core.Either import arrow.core.right import no.nav.su.se.bakover.common.ident.NavIdentBruker import no.nav.su.se.bakover.common.tid.Tidspunkt +import tilbakekreving.domain.kravgrunnlag.Kravgrunnlag import tilbakekreving.domain.kravgrunnlag.rått.RåTilbakekrevingsvedtakForsendelse +import tilbakekreving.domain.vedtak.KunneIkkeAnnullerePåbegynteVedtak import tilbakekreving.domain.vedtak.KunneIkkeSendeTilbakekrevingsvedtak import tilbakekreving.domain.vedtak.Tilbakekrevingsklient import tilbakekreving.domain.vurdering.VurderingerMedKrav @@ -24,4 +26,14 @@ data class TilbakekrevingsklientStub( responseXml = "{\"responseJson\": \"stubbed\"}", ).right() } + + override fun annullerKravgrunnlag( + annullertAv: NavIdentBruker.Saksbehandler, + kravgrunnlagSomSkalAnnulleres: Kravgrunnlag, + ): Either = + RåTilbakekrevingsvedtakForsendelse( + requestXml = "{\"requestJson\": \"stubbed\"}", + tidspunkt = Tidspunkt.now(clock), + responseXml = "{\"responseJson\": \"stubbed\"}", + ).right() } diff --git a/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/TilbakekrevingServices.kt b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/TilbakekrevingServices.kt index 3ed58cf4cd..25bab1770a 100644 --- a/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/TilbakekrevingServices.kt +++ b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/TilbakekrevingServices.kt @@ -18,6 +18,7 @@ import tilbakekreving.application.service.forhåndsvarsel.ForhåndsvarsleTilbake import tilbakekreving.application.service.forhåndsvarsel.ForhåndsvisForhåndsvarselTilbakekrevingsbehandlingService import tilbakekreving.application.service.forhåndsvarsel.VisUtsendtForhåndsvarselbrevForTilbakekrevingService import tilbakekreving.application.service.iverksett.IverksettTilbakekrevingService +import tilbakekreving.application.service.kravgrunnlag.AnnullerKravgrunnlagService import tilbakekreving.application.service.kravgrunnlag.OppdaterKravgrunnlagService import tilbakekreving.application.service.kravgrunnlag.RåttKravgrunnlagService import tilbakekreving.application.service.notat.NotatTilbakekrevingsbehandlingService @@ -60,6 +61,7 @@ class TilbakekrevingServices( val oppdaterKravgrunnlagService: OppdaterKravgrunnlagService, val notatTilbakekrevingsbehandlingService: NotatTilbakekrevingsbehandlingService, val vedtaksbrevTilbakekrevingKonsument: GenererVedtaksbrevTilbakekrevingKonsument, + val annullerKravgrunnlagService: AnnullerKravgrunnlagService, ) { companion object { fun create( @@ -210,6 +212,15 @@ class TilbakekrevingServices( sessionFactory = sessionFactory, clock = clock, ), + annullerKravgrunnlagService = AnnullerKravgrunnlagService( + tilgangstyring = tilgangstyringService, + tilbakekrevingsbehandlingRepo = tilbakekrevingsbehandlingRepo, + sakService = sakService, + kravgrunnlagRepo = kravgrunnlagRepo, + tilbakekrevingsklient = tilbakekrevingsklient, + sessionFactory = sessionFactory, + clock = clock, + ), ) } } diff --git a/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/consumer/KnyttKravgrunnlagTilSakOgUtbetalingKonsument.kt b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/consumer/KnyttKravgrunnlagTilSakOgUtbetalingKonsument.kt index 72c3ca0d0f..6b2894ee78 100644 --- a/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/consumer/KnyttKravgrunnlagTilSakOgUtbetalingKonsument.kt +++ b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/consumer/KnyttKravgrunnlagTilSakOgUtbetalingKonsument.kt @@ -38,11 +38,11 @@ class KnyttKravgrunnlagTilSakOgUtbetalingKonsument( override val konsumentId = HendelseskonsumentId("KnyttKravgrunnlagTilSakOgUtbetaling") /** - * Funksjonen logger feilene selv, men returnerer en throwable for testene sin del. + * Funksjonen logger feilene selv, men returnerer for testene sin del. */ fun knyttKravgrunnlagTilSakOgUtbetaling( correlationId: CorrelationId, - ): Either, Unit> { + ): Either, List> { return Either.catch { kravgrunnlagRepo.hentUprosesserteRåttKravgrunnlagHendelser( konsumentId = konsumentId, @@ -56,14 +56,16 @@ class KnyttKravgrunnlagTilSakOgUtbetalingKonsument( ) nonEmptyListOf(it) }.flatMap { - it.flattenOrAccumulate().map { } + it.flattenOrAccumulate().map { + it.mapNotNull { it.knyttetKravgrunnlagPåSakHendelse } + } } } private fun prosesserEnHendelse( hendelseId: HendelseId, correlationId: CorrelationId, - ): Either { + ): Either { return Either.catch { val (råttKravgrunnlagHendelse, meta) = kravgrunnlagRepo.hentRåttKravgrunnlagHendelseMedMetadataForHendelseId(hendelseId) ?: run { @@ -93,20 +95,30 @@ class KnyttKravgrunnlagTilSakOgUtbetalingKonsument( hendelseId = hendelseId, konsumentId = konsumentId, ) - return Unit.right() + return ProsseserteHendelser(hendelseId, null).right() } when (kravgrunnlagPåSakHendelse) { - is KravgrunnlagDetaljerPåSakHendelse -> prosesserDetaljer( - hendelseId = hendelseId, - kravgrunnlagPåSakHendelse = kravgrunnlagPåSakHendelse, - correlationId = correlationId, - ) + is KravgrunnlagDetaljerPåSakHendelse -> { + ProsseserteHendelser( + hendelseId, + prosesserDetaljer( + hendelseId = hendelseId, + kravgrunnlagPåSakHendelse = kravgrunnlagPåSakHendelse, + correlationId = correlationId, + ), + ) + } - is KravgrunnlagStatusendringPåSakHendelse -> prosesserStatus( - hendelseId = hendelseId, - kravgrunnlagPåSakHendelse = kravgrunnlagPåSakHendelse, - correlationId = correlationId, - ) + is KravgrunnlagStatusendringPåSakHendelse -> { + ProsseserteHendelser( + hendelseId, + prosesserStatus( + hendelseId = hendelseId, + kravgrunnlagPåSakHendelse = kravgrunnlagPåSakHendelse, + correlationId = correlationId, + ), + ) + } } }.onLeft { log.error("Kunne ikke prosessere kravgrunnlag: Det ble kastet en exception for hendelsen $hendelseId", it) @@ -117,7 +129,7 @@ class KnyttKravgrunnlagTilSakOgUtbetalingKonsument( hendelseId: HendelseId, kravgrunnlagPåSakHendelse: KravgrunnlagStatusendringPåSakHendelse, correlationId: CorrelationId, - ) { + ): HendelseId { // Statusendringene har ikke noen unik indikator i seg selv, annet enn JMS-meldingen sin id. Siden vi ikke får til noen god dedup. så vi aksepterer alle statusendringer. sessionFactory.withTransactionContext { tx -> kravgrunnlagRepo.lagreKravgrunnlagPåSakHendelse( @@ -131,13 +143,14 @@ class KnyttKravgrunnlagTilSakOgUtbetalingKonsument( context = tx, ) } + return kravgrunnlagPåSakHendelse.hendelseId } private fun prosesserDetaljer( hendelseId: HendelseId, kravgrunnlagPåSakHendelse: KravgrunnlagDetaljerPåSakHendelse, correlationId: CorrelationId, - ) { + ): HendelseId { sessionFactory.withTransactionContext { tx -> kravgrunnlagRepo.lagreKravgrunnlagPåSakHendelse( hendelse = kravgrunnlagPåSakHendelse, @@ -150,5 +163,14 @@ class KnyttKravgrunnlagTilSakOgUtbetalingKonsument( context = tx, ) } + return kravgrunnlagPåSakHendelse.hendelseId } } + +private data class ProsseserteHendelser( + /** + * aka tidligere hendelseId for nye hendelsen som er blitt knyttet til saken + */ + val hendelsenSomErBlittProsessert: HendelseId, + val knyttetKravgrunnlagPåSakHendelse: HendelseId?, +) diff --git a/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/kravgrunnlag/AnnullerKravgrunnlagService.kt b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/kravgrunnlag/AnnullerKravgrunnlagService.kt new file mode 100644 index 0000000000..4aaa8c4b89 --- /dev/null +++ b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/kravgrunnlag/AnnullerKravgrunnlagService.kt @@ -0,0 +1,100 @@ +package tilbakekreving.application.service.kravgrunnlag + +import arrow.core.Either +import arrow.core.getOrElse +import arrow.core.left +import no.nav.su.se.bakover.common.persistence.SessionFactory +import no.nav.su.se.bakover.common.tid.Tidspunkt +import no.nav.su.se.bakover.domain.sak.SakService +import no.nav.su.se.bakover.hendelse.domain.HendelseId +import org.slf4j.LoggerFactory +import tilbakekreving.domain.AvbruttTilbakekrevingsbehandling +import tilbakekreving.domain.KanAnnullere +import tilbakekreving.domain.TilbakekrevingsbehandlingRepo +import tilbakekreving.domain.kravgrunnlag.AnnullerKravgrunnlagCommand +import tilbakekreving.domain.kravgrunnlag.Kravgrunnlagstatus +import tilbakekreving.domain.kravgrunnlag.påsak.KravgrunnlagStatusendringPåSakHendelse +import tilbakekreving.domain.kravgrunnlag.repo.AnnullerKravgrunnlagStatusEndringMeta +import tilbakekreving.domain.kravgrunnlag.repo.KravgrunnlagRepo +import tilbakekreving.domain.vedtak.Tilbakekrevingsklient +import tilgangstyring.application.TilgangstyringService +import java.time.Clock + +class AnnullerKravgrunnlagService( + private val tilgangstyring: TilgangstyringService, + private val tilbakekrevingsbehandlingRepo: TilbakekrevingsbehandlingRepo, + private val sakService: SakService, + private val kravgrunnlagRepo: KravgrunnlagRepo, + private val tilbakekrevingsklient: Tilbakekrevingsklient, + private val sessionFactory: SessionFactory, + private val clock: Clock, +) { + private val log = LoggerFactory.getLogger(this::class.java) + + fun annuller(command: AnnullerKravgrunnlagCommand): Either { + tilgangstyring.assertHarTilgangTilSak(command.sakId).onLeft { + return KunneIkkeAnnullereKravgrunnlag.IkkeTilgang(it).left() + } + val sak = sakService.hentSak(command.sakId).getOrElse { + throw IllegalStateException("Kunne ikke oppdatere kravgrunnlag for tilbakekrevingsbehandling, fant ikke sak. Command: $command") + } + if (sak.versjon != command.klientensSisteSaksversjon) { + log.info("Oppdater kravgrunnlag - Sakens versjon (${sak.versjon}) er ulik saksbehandlers versjon. Command: $command") + } + val tilbakekrevingsbehandlingHendelser = tilbakekrevingsbehandlingRepo.hentForSak(command.sakId) + val uteståendeKravgrunnlagPåSak = tilbakekrevingsbehandlingHendelser.hentUteståendeKravgrunnlag() + ?: return KunneIkkeAnnullereKravgrunnlag.SakenHarIkkeKravgrunnlagSomKanAnnulleres.left() + val kravgrunnlag = tilbakekrevingsbehandlingHendelser.hentKravrunnlag(command.kravgrunnlagHendelseId) + ?: return KunneIkkeAnnullereKravgrunnlag.FantIkkeKravgrunnlag.left() + + if (uteståendeKravgrunnlagPåSak.hendelseId != kravgrunnlag.hendelseId) { + return KunneIkkeAnnullereKravgrunnlag.InnsendtHendelseIdErIkkeDenSistePåSaken.left() + } + + val behandling = + tilbakekrevingsbehandlingHendelser.hentBehandlingForKravgrunnlag(uteståendeKravgrunnlagPåSak.hendelseId) + + val (avbruttHendelse, avbruttBehandling) = behandling?.let { + (it as? KanAnnullere)?.annuller( + annulleringstidspunkt = Tidspunkt.now(clock), + annullertAv = command.annullertAv, + versjon = command.klientensSisteSaksversjon.inc(), + ) ?: return KunneIkkeAnnullereKravgrunnlag.BehandlingenErIFeilTilstandForÅAnnullere.left() + } ?: (null to null) + + return tilbakekrevingsklient.annullerKravgrunnlag(command.annullertAv, kravgrunnlag).mapLeft { + KunneIkkeAnnullereKravgrunnlag.FeilMotTilbakekrevingskomponenten(it) + }.map { råTilbakekrevingsvedtakForsendelse -> + sessionFactory.withTransactionContext { + kravgrunnlagRepo.lagreKravgrunnlagPåSakHendelse( + KravgrunnlagStatusendringPåSakHendelse( + hendelseId = HendelseId.generer(), + versjon = if (avbruttHendelse == null) command.klientensSisteSaksversjon.inc() else command.klientensSisteSaksversjon.inc(2), + sakId = sak.id, + hendelsestidspunkt = Tidspunkt.now(clock), + tidligereHendelseId = uteståendeKravgrunnlagPåSak.hendelseId, + saksnummer = sak.saksnummer, + eksternVedtakId = uteståendeKravgrunnlagPåSak.eksternVedtakId, + status = Kravgrunnlagstatus.Annullert, + eksternTidspunkt = råTilbakekrevingsvedtakForsendelse.tidspunkt, + ), + AnnullerKravgrunnlagStatusEndringMeta( + correlationId = command.correlationId, + ident = command.annullertAv, + brukerroller = command.brukerroller, + tilbakekrevingsvedtakForsendelse = råTilbakekrevingsvedtakForsendelse, + ), + it, + ) + if (avbruttHendelse != null) { + tilbakekrevingsbehandlingRepo.lagre( + hendelse = avbruttHendelse, + meta = command.toDefaultHendelsesMetadata(), + sessionContext = it, + ) + } + } + avbruttBehandling + } + } +} diff --git a/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/kravgrunnlag/KunneIkkeAnnullereKravgrunnlag.kt b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/kravgrunnlag/KunneIkkeAnnullereKravgrunnlag.kt new file mode 100644 index 0000000000..d1e5215cac --- /dev/null +++ b/tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/kravgrunnlag/KunneIkkeAnnullereKravgrunnlag.kt @@ -0,0 +1,14 @@ +package tilbakekreving.application.service.kravgrunnlag + +import tilbakekreving.domain.vedtak.KunneIkkeAnnullerePåbegynteVedtak +import tilgangstyring.domain.IkkeTilgangTilSak + +sealed interface KunneIkkeAnnullereKravgrunnlag { + data class IkkeTilgang(val underliggende: IkkeTilgangTilSak) : KunneIkkeAnnullereKravgrunnlag + data object InnsendtHendelseIdErIkkeDenSistePåSaken : KunneIkkeAnnullereKravgrunnlag + data object SakenHarIkkeKravgrunnlagSomKanAnnulleres : KunneIkkeAnnullereKravgrunnlag + data object FantIkkeKravgrunnlag : KunneIkkeAnnullereKravgrunnlag + data object BehandlingenErIFeilTilstandForÅAnnullere : KunneIkkeAnnullereKravgrunnlag + data class FeilMotTilbakekrevingskomponenten(val underliggende: KunneIkkeAnnullerePåbegynteVedtak) : + KunneIkkeAnnullereKravgrunnlag +} diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/KanEndres.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/KanEndres.kt index a5926033a0..b47f253b11 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/KanEndres.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/KanEndres.kt @@ -7,6 +7,7 @@ package tilbakekreving.domain * - oppdatere vedtaksbrev * - oppdatere notat * - oppdatere kravgrunnlag + * - annullere kravgrunnlag */ sealed interface KanEndres : Tilbakekrevingsbehandling { override fun erÅpen() = true diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/TilbakekrevingsbehandlingHendelser.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/TilbakekrevingsbehandlingHendelser.kt index d77979dc45..8db1356524 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/TilbakekrevingsbehandlingHendelser.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/TilbakekrevingsbehandlingHendelser.kt @@ -4,6 +4,7 @@ import dokument.domain.DokumentHendelseSerie import dokument.domain.DokumentHendelser import dokument.domain.Dokumenttilstand import no.nav.su.se.bakover.common.domain.Saksnummer +import no.nav.su.se.bakover.common.domain.extensions.singleOrNullOrThrow import no.nav.su.se.bakover.common.person.Fnr import no.nav.su.se.bakover.hendelse.domain.HendelseId import tilbakekreving.domain.kravgrunnlag.Kravgrunnlag @@ -204,6 +205,15 @@ data class TilbakekrevingsbehandlingHendelser private constructor( hendelser = sorterteHendelser.filter { it.id == behandlingsid }, ) + fun hentKravrunnlag(kravgrunnlagHendelseId: HendelseId): Kravgrunnlag? { + return kravgrunnlagPåSak.hentKravgrunnlagDetaljerPåSakHendelseForHendelseId(kravgrunnlagHendelseId)?.kravgrunnlag + } + + fun hentBehandlingForKravgrunnlag(kravgrunnlagHendelseId: HendelseId): Tilbakekrevingsbehandling? = + this.currentState.behandlinger.singleOrNullOrThrow { + it.kravgrunnlag.hendelseId == kravgrunnlagHendelseId && it.erÅpen() + } + /** * Henter det siste utestående kravgrunnlaget, dersom det finnes et kravgrunnlag og det ikke er avsluttet. * Det er kun det siste mottatte kravgrunnlaget som kan være utestående. diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/UnderBehandling.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/UnderBehandling.kt index affe1e0562..95f301bd6e 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/UnderBehandling.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/UnderBehandling.kt @@ -27,6 +27,7 @@ sealed interface UnderBehandling : KanVurdere, KanForhåndsvarsle, KanOppdatereNotat, + KanAnnullere, UnderBehandlingEllerTilAttestering { override val vurderingerMedKrav: VurderingerMedKrav? diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/annuller/KanAnnullere.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/annuller/KanAnnullere.kt new file mode 100644 index 0000000000..d942bd0095 --- /dev/null +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/annuller/KanAnnullere.kt @@ -0,0 +1,29 @@ +@file:Suppress("PackageDirectoryMismatch") +// Må ligge i samme pakke som Tilbakekrevingsbehandling (siden det er et sealed interface), men trenger ikke ligge i samme mappe. + +package tilbakekreving.domain + +import no.nav.su.se.bakover.common.ident.NavIdentBruker +import no.nav.su.se.bakover.common.tid.Tidspunkt +import no.nav.su.se.bakover.hendelse.domain.HendelseId +import no.nav.su.se.bakover.hendelse.domain.Hendelsesversjon + +sealed interface KanAnnullere : KanEndres { + fun annuller( + annulleringstidspunkt: Tidspunkt, + annullertAv: NavIdentBruker.Saksbehandler, + versjon: Hendelsesversjon, + ): Pair { + val hendelse = AvbruttHendelse( + hendelseId = HendelseId.generer(), + id = this.id, + utførtAv = annullertAv, + tidligereHendelseId = this.hendelseId, + hendelsestidspunkt = annulleringstidspunkt, + sakId = this.sakId, + versjon = versjon, + begrunnelse = "Behandling er blitt avbrutt fordi kravgrunnlaget skal annulleres.", + ) + return hendelse to hendelse.applyToState(this) + } +} diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/AnnullerKravgrunnlagCommand.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/AnnullerKravgrunnlagCommand.kt new file mode 100644 index 0000000000..74b92feedf --- /dev/null +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/AnnullerKravgrunnlagCommand.kt @@ -0,0 +1,27 @@ +package tilbakekreving.domain.kravgrunnlag + +import no.nav.su.se.bakover.common.CorrelationId +import no.nav.su.se.bakover.common.brukerrolle.Brukerrolle +import no.nav.su.se.bakover.common.ident.NavIdentBruker +import no.nav.su.se.bakover.hendelse.domain.DefaultHendelseMetadata +import no.nav.su.se.bakover.hendelse.domain.HendelseId +import no.nav.su.se.bakover.hendelse.domain.Hendelsesversjon +import no.nav.su.se.bakover.hendelse.domain.SakshendelseCommand +import java.util.UUID + +data class AnnullerKravgrunnlagCommand( + override val sakId: UUID, + override val correlationId: CorrelationId?, + override val brukerroller: List, + val annullertAv: NavIdentBruker.Saksbehandler, + val kravgrunnlagHendelseId: HendelseId, + val klientensSisteSaksversjon: Hendelsesversjon, +) : SakshendelseCommand { + override val utførtAv: NavIdentBruker = annullertAv + + fun toDefaultHendelsesMetadata() = DefaultHendelseMetadata( + correlationId = correlationId, + ident = this.utførtAv, + brukerroller = brukerroller, + ) +} diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/Kravgrunnlagstatus.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/Kravgrunnlagstatus.kt index 5d5991dcf2..049705b404 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/Kravgrunnlagstatus.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/Kravgrunnlagstatus.kt @@ -1,5 +1,8 @@ package tilbakekreving.domain.kravgrunnlag +/** + * Statuser som kan komme fra oppdrag: https://confluence.adeo.no/display/OKSY/Detaljer+om+de+enkelte+ID-koder?preview=/178067795/334793028/Skjermbilde%20M437.GIF + */ enum class Kravgrunnlagstatus { Annullert, diff --git "a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/OppdatertKravgrunnlagP\303\245TilbakekrevingHendelse.kt" "b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/OppdatertKravgrunnlagP\303\245TilbakekrevingHendelse.kt" index 35976943e4..783dc8eb09 100644 --- "a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/OppdatertKravgrunnlagP\303\245TilbakekrevingHendelse.kt" +++ "b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/OppdatertKravgrunnlagP\303\245TilbakekrevingHendelse.kt" @@ -11,6 +11,10 @@ import no.nav.su.se.bakover.hendelse.domain.Sakshendelse import tilbakekreving.domain.kravgrunnlag.Kravgrunnlag import java.util.UUID +/** + * Forholder seg til eksterne oppdateringer fra oppdrag. + * Lag en ny hendelsestype dersom du skal oppdatere kravgrunnlaget fra vår side + */ data class OppdatertKravgrunnlagPåTilbakekrevingHendelse( override val hendelseId: HendelseId, override val sakId: UUID, diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/AnnullerKravgrunnlagStatusEndringMeta.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/AnnullerKravgrunnlagStatusEndringMeta.kt new file mode 100644 index 0000000000..65703a49f3 --- /dev/null +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/AnnullerKravgrunnlagStatusEndringMeta.kt @@ -0,0 +1,14 @@ +package tilbakekreving.domain.kravgrunnlag.repo + +import no.nav.su.se.bakover.common.CorrelationId +import no.nav.su.se.bakover.common.brukerrolle.Brukerrolle +import no.nav.su.se.bakover.common.ident.NavIdentBruker +import no.nav.su.se.bakover.hendelse.domain.HendelseMetadata +import tilbakekreving.domain.kravgrunnlag.rått.RåTilbakekrevingsvedtakForsendelse + +data class AnnullerKravgrunnlagStatusEndringMeta( + override val correlationId: CorrelationId?, + override val ident: NavIdentBruker?, + override val brukerroller: List, + val tilbakekrevingsvedtakForsendelse: RåTilbakekrevingsvedtakForsendelse, +) : HendelseMetadata diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/KravgrunnlagRepo.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/KravgrunnlagRepo.kt index 72ca09d766..ec156679d3 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/KravgrunnlagRepo.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/kravgrunnlag/repo/KravgrunnlagRepo.kt @@ -28,6 +28,12 @@ interface KravgrunnlagRepo { sessionContext: SessionContext? = null, ): Pair? + fun lagreKravgrunnlagPåSakHendelse( + hendelse: KravgrunnlagPåSakHendelse, + meta: AnnullerKravgrunnlagStatusEndringMeta, + sessionContext: SessionContext? = null, + ) + fun lagreKravgrunnlagPåSakHendelse( hendelse: KravgrunnlagPåSakHendelse, meta: DefaultHendelseMetadata, diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/opprettelse/OpprettetTilbakekrevingsbehandling.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/opprettelse/OpprettetTilbakekrevingsbehandling.kt index 6b6f719442..9557088b4b 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/opprettelse/OpprettetTilbakekrevingsbehandling.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/opprettelse/OpprettetTilbakekrevingsbehandling.kt @@ -28,7 +28,7 @@ data class OpprettetTilbakekrevingsbehandling( override val versjon: Hendelsesversjon, override val hendelseId: HendelseId, override val erKravgrunnlagUtdatert: Boolean, -) : KanForhåndsvarsle, KanVurdere, KanOppdatereKravgrunnlag, KanOppdatereNotat { +) : KanForhåndsvarsle, KanVurdere, KanOppdatereKravgrunnlag, KanOppdatereNotat, KanAnnullere { override val attesteringer: Attesteringshistorikk = Attesteringshistorikk.empty() override val forhåndsvarselsInfo: List = emptyList() diff --git a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/vedtak/Tilbakekrevingsklient.kt b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/vedtak/Tilbakekrevingsklient.kt index ef917dd132..7b717a54c5 100644 --- a/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/vedtak/Tilbakekrevingsklient.kt +++ b/tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/vedtak/Tilbakekrevingsklient.kt @@ -2,6 +2,7 @@ package tilbakekreving.domain.vedtak import arrow.core.Either import no.nav.su.se.bakover.common.ident.NavIdentBruker +import tilbakekreving.domain.kravgrunnlag.Kravgrunnlag import tilbakekreving.domain.kravgrunnlag.rått.RåTilbakekrevingsvedtakForsendelse import tilbakekreving.domain.vurdering.VurderingerMedKrav @@ -15,4 +16,14 @@ interface Tilbakekrevingsklient { vurderingerMedKrav: VurderingerMedKrav, attestertAv: NavIdentBruker.Attestant, ): Either + + fun annullerKravgrunnlag( + annullertAv: NavIdentBruker.Saksbehandler, + kravgrunnlagSomSkalAnnulleres: Kravgrunnlag, + ): Either +} + +sealed interface KunneIkkeAnnullerePåbegynteVedtak { + data object FeilStatusFraOppdrag : KunneIkkeAnnullerePåbegynteVedtak + data object UkjentFeil : KunneIkkeAnnullerePåbegynteVedtak } diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingAnnuleringSoapRequest.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingAnnuleringSoapRequest.kt new file mode 100644 index 0000000000..7daabc4a02 --- /dev/null +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingAnnuleringSoapRequest.kt @@ -0,0 +1,24 @@ +@file:Suppress("HttpUrlsUsage") + +package tilbakekreving.infrastructure.client + +/** + * https://confluence.adeo.no/display/OKSY/Detaljer+om+de+enkelte+ID-koder + * https://confluence.adeo.no/display/OKSY/Detaljer+om+de+enkelte+ID-koder?preview=/178067795/178067800/worddav1549728a4f1bb4ae0651e7017a7cae86.png + */ +internal fun buildTilbakekrevingAnnulleringSoapRequest( + eksternVedtakId: String, + saksbehandletAv: String, +): String { + return """ + + + A + $eksternVedtakId + $saksbehandletAv + + + """.trimIndent() +} diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClient.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClient.kt index 93a64a42e0..3be2839ae4 100644 --- a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClient.kt +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClient.kt @@ -14,7 +14,9 @@ import no.nav.su.se.bakover.common.infrastructure.soap.buildSoapEnvelope import no.nav.su.se.bakover.common.sikkerLogg import no.nav.su.se.bakover.common.tid.Tidspunkt import org.slf4j.LoggerFactory +import tilbakekreving.domain.kravgrunnlag.Kravgrunnlag import tilbakekreving.domain.kravgrunnlag.rått.RåTilbakekrevingsvedtakForsendelse +import tilbakekreving.domain.vedtak.KunneIkkeAnnullerePåbegynteVedtak import tilbakekreving.domain.vedtak.KunneIkkeSendeTilbakekrevingsvedtak import tilbakekreving.domain.vedtak.Tilbakekrevingsklient import tilbakekreving.domain.vurdering.VurderingerMedKrav @@ -99,7 +101,8 @@ class TilbakekrevingSoapClient( RåTilbakekrevingsvedtakForsendelse( requestXml = soapRequest, tidspunkt = Tidspunkt.now(clock), - responseXml = soapResponse ?: "soapResponse var null - dette er sannsynligvis en teksnisk feil, f.eks. ved at http-body er lest mer enn 1 gang.", + responseXml = soapResponse + ?: "soapResponse var null - dette er sannsynligvis en teksnisk feil, f.eks. ved at http-body er lest mer enn 1 gang.", ) } }.mapLeft { throwable -> @@ -115,6 +118,74 @@ class TilbakekrevingSoapClient( }.flatten() } + /* + https://confluence.adeo.no/display/OKSY/Detaljer+om+de+enkelte+ID-koder?preview=/178067795/178067800/worddav1549728a4f1bb4ae0651e7017a7cae86.png + */ + override fun annullerKravgrunnlag( + annullertAv: NavIdentBruker.Saksbehandler, + kravgrunnlagSomSkalAnnulleres: Kravgrunnlag, + ): Either { + val soapBody = buildTilbakekrevingAnnulleringSoapRequest( + eksternVedtakId = kravgrunnlagSomSkalAnnulleres.eksternKravgrunnlagId, + saksbehandletAv = annullertAv.navIdent, + ) + val saksnummer = kravgrunnlagSomSkalAnnulleres.saksnummer + + val assertion = getSamlToken(kravgrunnlagSomSkalAnnulleres.saksnummer, soapBody).getOrElse { TODO() } + + return Either.catch { + val soapRequest = buildSoapEnvelope( + action = ACTION, + messageId = UUID.randomUUID().toString(), + serviceUrl = baseUrl, + assertion = assertion, + body = soapBody, + ) + val httpRequest = HttpRequest.newBuilder(URI(baseUrl)) + .header("SOAPAction", ACTION) + .POST(HttpRequest.BodyPublishers.ofString(soapRequest)) + .build() + val (soapResponse: String?, status: Int) = client.send(httpRequest, HttpResponse.BodyHandlers.ofString()) + .let { + it.body() to it.statusCode() + } + + if (status != 200) { + log.error( + "Feil ved sending av tilbakekrevingsvedtak: Forventet statusCode 200 for saksnummer: $saksnummer, statusCode: $status. Se sikkerlogg for request.", + RuntimeException("Trigger stacktrace"), + ) + sikkerLogg.error("Feil ved sending av tilbakekrevingsvedtak: Forventet statusCode 200 for saksnummer: $saksnummer, statusCode: $status, Response: $soapResponse Request: $soapRequest") + return KunneIkkeAnnullerePåbegynteVedtak.FeilStatusFraOppdrag.left() + } + + kontrollerResponse(soapRequest, soapResponse, saksnummer) + .map { + log.info("SOAP kall mot tilbakekrevingskomponenten OK for saksnummer $saksnummer. Se sikkerlogg for detaljer.") + sikkerLogg.info("SOAP kall mot tilbakekrevingskomponenten OK for saksnummer $saksnummer. Response: $soapResponse, Request: $soapRequest.") + + RåTilbakekrevingsvedtakForsendelse( + requestXml = soapRequest, + tidspunkt = Tidspunkt.now(clock), + responseXml = soapResponse + ?: "soapResponse var null - dette er sannsynligvis en teksnisk feil, f.eks. ved at http-body er lest mer enn 1 gang.", + ) + }.mapLeft { + KunneIkkeAnnullerePåbegynteVedtak.FeilStatusFraOppdrag + } + }.mapLeft { throwable -> + log.error( + "SOAP kall mot tilbakekrevingskomponenten feilet for saksnummer $saksnummer og eksternKravgrunnlagId ${kravgrunnlagSomSkalAnnulleres.eksternKravgrunnlagId}. Se sikkerlogg for detaljer.", + RuntimeException("Legger på stacktrace for enklere debug"), + ) + sikkerLogg.error( + "SOAP kall mot tilbakekrevingskomponenten feilet for saksnummer $saksnummer og eksternKravgrunnlagId ${kravgrunnlagSomSkalAnnulleres.eksternKravgrunnlagId}. Se vanlig logg for stacktrace.", + throwable, + ) + KunneIkkeAnnullerePåbegynteVedtak.UkjentFeil + }.flatten() + } + private fun getSamlToken( saksnummer: Saksnummer, soapBody: String, diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/TilbakekrevingsvedtakForsendelseDbJson.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/TilbakekrevingsvedtakForsendelseDbJson.kt new file mode 100644 index 0000000000..54575bb604 --- /dev/null +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/TilbakekrevingsvedtakForsendelseDbJson.kt @@ -0,0 +1,9 @@ +package tilbakekreving.infrastructure.repo + +import no.nav.su.se.bakover.common.tid.Tidspunkt + +data class TilbakekrevingsvedtakForsendelseDbJson( + val requestXml: String, + val tidspunkt: Tidspunkt, + val responseXml: String, +) diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/iverksatt/IverksattHendelseMetadataDbJson.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/iverksatt/IverksattHendelseMetadataDbJson.kt index b70c356d34..ec899eadb2 100644 --- a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/iverksatt/IverksattHendelseMetadataDbJson.kt +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/iverksatt/IverksattHendelseMetadataDbJson.kt @@ -3,21 +3,15 @@ package tilbakekreving.infrastructure.repo.iverksatt import no.nav.su.se.bakover.common.infrastructure.ident.BrukerrolleJson import no.nav.su.se.bakover.common.infrastructure.ident.toBrukerrollerJson import no.nav.su.se.bakover.common.serialize -import no.nav.su.se.bakover.common.tid.Tidspunkt import tilbakekreving.domain.iverksettelse.IverksattHendelseMetadata +import tilbakekreving.infrastructure.repo.TilbakekrevingsvedtakForsendelseDbJson data class IverksattHendelseMetadataDbJson( val correlationId: String, val ident: String, val brukerroller: List, val tilbakekrevingsvedtakForsendelse: TilbakekrevingsvedtakForsendelseDbJson, -) { - data class TilbakekrevingsvedtakForsendelseDbJson( - val requestXml: String, - val tidspunkt: Tidspunkt, - val responseXml: String, - ) -} +) fun IverksattHendelseMetadata.toDbJson(): String { return serialize( @@ -25,7 +19,7 @@ fun IverksattHendelseMetadata.toDbJson(): String { correlationId = correlationId.toString(), ident = ident.toString(), brukerroller = brukerroller.toBrukerrollerJson(), - tilbakekrevingsvedtakForsendelse = IverksattHendelseMetadataDbJson.TilbakekrevingsvedtakForsendelseDbJson( + tilbakekrevingsvedtakForsendelse = TilbakekrevingsvedtakForsendelseDbJson( requestXml = tilbakekrevingsvedtakForsendelse.requestXml, tidspunkt = tilbakekrevingsvedtakForsendelse.tidspunkt, responseXml = tilbakekrevingsvedtakForsendelse.responseXml, diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/AnnullerKravgrunnlagStatusEndringMetaJson.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/AnnullerKravgrunnlagStatusEndringMetaJson.kt new file mode 100644 index 0000000000..33fcc4e1f2 --- /dev/null +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/AnnullerKravgrunnlagStatusEndringMetaJson.kt @@ -0,0 +1,29 @@ +package tilbakekreving.infrastructure.repo.kravgrunnlag + +import no.nav.su.se.bakover.common.infrastructure.ident.BrukerrolleJson +import no.nav.su.se.bakover.common.infrastructure.ident.toBrukerrollerJson +import no.nav.su.se.bakover.common.serialize +import tilbakekreving.domain.kravgrunnlag.repo.AnnullerKravgrunnlagStatusEndringMeta +import tilbakekreving.infrastructure.repo.TilbakekrevingsvedtakForsendelseDbJson + +data class AnnullerKravgrunnlagStatusEndringMetaJson( + val correlationId: String, + val ident: String, + val brukerroller: List, + val tilbakekrevingsvedtakForsendelse: TilbakekrevingsvedtakForsendelseDbJson, +) + +fun AnnullerKravgrunnlagStatusEndringMeta.toDbJson(): String { + return serialize( + AnnullerKravgrunnlagStatusEndringMetaJson( + correlationId = correlationId.toString(), + ident = ident.toString(), + brukerroller = brukerroller.toBrukerrollerJson(), + tilbakekrevingsvedtakForsendelse = TilbakekrevingsvedtakForsendelseDbJson( + requestXml = tilbakekrevingsvedtakForsendelse.requestXml, + tidspunkt = tilbakekrevingsvedtakForsendelse.tidspunkt, + responseXml = tilbakekrevingsvedtakForsendelse.responseXml, + ), + ), + ) +} diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagPostgresRepo.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagPostgresRepo.kt index 482b4906b4..2f91d44753 100644 --- a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagPostgresRepo.kt +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagPostgresRepo.kt @@ -12,6 +12,7 @@ import no.nav.su.se.bakover.hendelse.infrastructure.persistence.HendelsePostgres import no.nav.su.se.bakover.hendelse.infrastructure.persistence.toDbJson import tilbakekreving.domain.kravgrunnlag.påsak.KravgrunnlagPåSakHendelse import tilbakekreving.domain.kravgrunnlag.påsak.KravgrunnlagPåSakHendelser +import tilbakekreving.domain.kravgrunnlag.repo.AnnullerKravgrunnlagStatusEndringMeta import tilbakekreving.domain.kravgrunnlag.repo.KravgrunnlagRepo import tilbakekreving.domain.kravgrunnlag.rått.RåttKravgrunnlagHendelse import tilbakekreving.infrastructure.repo.kravgrunnlag.RåttKravgrunnlagDbJson.Companion.toJson @@ -69,9 +70,6 @@ class KravgrunnlagPostgresRepo( } } - /** - * Denne er kun tenkt brukt av jobben som knytter kravgrunnlag til sak. - */ override fun lagreKravgrunnlagPåSakHendelse( hendelse: KravgrunnlagPåSakHendelse, meta: DefaultHendelseMetadata, @@ -86,6 +84,20 @@ class KravgrunnlagPostgresRepo( ) } + override fun lagreKravgrunnlagPåSakHendelse( + hendelse: KravgrunnlagPåSakHendelse, + meta: AnnullerKravgrunnlagStatusEndringMeta, + sessionContext: SessionContext?, + ) { + (hendelseRepo as HendelsePostgresRepo).persisterHendelse( + hendelse = hendelse, + type = KnyttetKravgrunnlagTilSakHendelsestype, + data = hendelse.toDbJson(), + meta = meta.toDbJson(), + sessionContext = sessionContext, + ) + } + /** * Kun tenkt brukt av jobben som ferdigstiller revurdering med tilbakekreving inntil tilbakekreving ikke lenger er en del av revurdering. * Husk og marker hendelsen som prosessert etter at den er behandlet. diff --git a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagStatusDbJson.kt b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagStatusDbJson.kt index f40524ae78..810adeda3b 100644 --- a/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagStatusDbJson.kt +++ b/tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/repo/kravgrunnlag/KravgrunnlagStatusDbJson.kt @@ -5,7 +5,7 @@ import tilbakekreving.domain.kravgrunnlag.Kravgrunnlagstatus fun Kravgrunnlagstatus.toDbString(): String = when (this) { Kravgrunnlagstatus.Annullert -> "Annullert" - Kravgrunnlagstatus.AnnullertVedOmg -> "AnnulertVedOmg" + Kravgrunnlagstatus.AnnullertVedOmg -> "AnnullertVedOmg" Kravgrunnlagstatus.Avsluttet -> "Avsluttet" Kravgrunnlagstatus.Ferdigbehandlet -> "Ferdigbehandlet" Kravgrunnlagstatus.Endret -> "Endret" @@ -17,8 +17,8 @@ fun Kravgrunnlagstatus.toDbString(): String = fun String.toKravgrunnlagStatus(): Kravgrunnlagstatus { return when (this) { - "Annulert" -> Kravgrunnlagstatus.Annullert - "AnnulertVedOmg" -> Kravgrunnlagstatus.AnnullertVedOmg + "Annullert" -> Kravgrunnlagstatus.Annullert + "AnnullertVedOmg" -> Kravgrunnlagstatus.AnnullertVedOmg "Avsluttet" -> Kravgrunnlagstatus.Avsluttet "Ferdigbehandlet" -> Kravgrunnlagstatus.Ferdigbehandlet "Endret" -> Kravgrunnlagstatus.Endret diff --git a/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClientTest.kt b/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClientTest.kt index eee66b3a2b..4b23b94dce 100644 --- a/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClientTest.kt +++ b/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/TilbakekrevingSoapClientTest.kt @@ -10,6 +10,8 @@ import no.nav.su.se.bakover.test.auth.FakeSamlTokenProvider import no.nav.su.se.bakover.test.fixedClock import no.nav.su.se.bakover.test.fixedTidspunkt import no.nav.su.se.bakover.test.getOrFail +import no.nav.su.se.bakover.test.kravgrunnlag.kravgrunnlag +import no.nav.su.se.bakover.test.saksbehandler import no.nav.su.se.bakover.test.tilbakekreving.tilbakekrevingSoapResponseConversionError import no.nav.su.se.bakover.test.tilbakekreving.tilbakekrevingSoapResponseOk import no.nav.su.se.bakover.test.tilbakekreving.tilbakekrevingSoapResponseVedtakIdFinnesIkke @@ -84,6 +86,30 @@ internal class TilbakekrevingSoapClientTest { ) } } + + @Test + fun `annullerer et kravgrunnlag`() { + val responseXml = tilbakekrevingSoapResponseOk() + + startedWireMockServerWithCorrelationId { + stubFor(wiremockBuilder("/c").willReturn(WireMock.okXml(responseXml))) + TilbakekrevingSoapClient( + baseUrl = "${this.baseUrl()}/c", + samlTokenProvider = FakeSamlTokenProvider(), + clock = fixedClock, + ).annullerKravgrunnlag( + annullertAv = saksbehandler, + kravgrunnlagSomSkalAnnulleres = kravgrunnlag(), + ).getOrFail().shouldBeEqualToIgnoringFields( + RåTilbakekrevingsvedtakForsendelse( + requestXml = "ignore-me", + responseXml = responseXml, + tidspunkt = fixedTidspunkt, + ), + RåTilbakekrevingsvedtakForsendelse::requestXml, + ) + } + } } private fun wiremockBuilder(testUrl: String): MappingBuilder = diff --git a/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/dto/TilbakekrevingAnnulleringSoakRequest.kt b/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/dto/TilbakekrevingAnnulleringSoakRequest.kt new file mode 100644 index 0000000000..6b54647028 --- /dev/null +++ b/tilbakekreving/infrastructure/src/test/kotlin/tilbakekreving/infrastructure/client/dto/TilbakekrevingAnnulleringSoakRequest.kt @@ -0,0 +1,29 @@ +package tilbakekreving.infrastructure.client.dto + +import io.kotest.matchers.shouldBe +import org.junit.jupiter.api.Test +import tilbakekreving.infrastructure.client.buildTilbakekrevingAnnulleringSoapRequest + +class TilbakekrevingAnnulleringSoakRequest { + + @Test + fun `lager soap body`() { + val eksternVedtakId = "123" + val saksbehandletAv = "saksbehandletAv" + + buildTilbakekrevingAnnulleringSoapRequest( + eksternVedtakId, + saksbehandletAv, + ) shouldBe """ + + + A + $eksternVedtakId + $saksbehandletAv + + + """.trimIndent() + } +} diff --git a/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/TilbakekrevingsbehandlingRoutes.kt b/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/TilbakekrevingsbehandlingRoutes.kt index 5cf602870a..fb2d37d14b 100644 --- a/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/TilbakekrevingsbehandlingRoutes.kt +++ b/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/TilbakekrevingsbehandlingRoutes.kt @@ -6,6 +6,7 @@ import tilbakekreving.application.service.forhåndsvarsel.ForhåndsvarsleTilbake import tilbakekreving.application.service.forhåndsvarsel.ForhåndsvisForhåndsvarselTilbakekrevingsbehandlingService import tilbakekreving.application.service.forhåndsvarsel.VisUtsendtForhåndsvarselbrevForTilbakekrevingService import tilbakekreving.application.service.iverksett.IverksettTilbakekrevingService +import tilbakekreving.application.service.kravgrunnlag.AnnullerKravgrunnlagService import tilbakekreving.application.service.kravgrunnlag.OppdaterKravgrunnlagService import tilbakekreving.application.service.notat.NotatTilbakekrevingsbehandlingService import tilbakekreving.application.service.opprett.OpprettTilbakekrevingsbehandlingService @@ -19,6 +20,7 @@ import tilbakekreving.presentation.api.forhåndsvarsel.forhåndsvarsleTilbakekre import tilbakekreving.presentation.api.forhåndsvarsel.visForhåndsvarselTilbakekrevingsbrev import tilbakekreving.presentation.api.forhåndsvarsel.visUtsendtForhåndsvarselbrevForTilbakekrevingRoute import tilbakekreving.presentation.api.iverksett.iverksettTilbakekrevingsbehandlingRoute +import tilbakekreving.presentation.api.kravgrunnlag.annullerKravgrunnlagRoute import tilbakekreving.presentation.api.kravgrunnlag.oppdaterKravgrunnlagRoute import tilbakekreving.presentation.api.notat.notatTilbakekrevingsbehandlingRoute import tilbakekreving.presentation.api.opprett.opprettTilbakekrevingsbehandlingRoute @@ -43,6 +45,7 @@ fun Route.tilbakekrevingRoutes( avbrytTilbakekrevingsbehandlingService: AvbrytTilbakekrevingsbehandlingService, oppdaterKravgrunnlagService: OppdaterKravgrunnlagService, notatTilbakekrevingsbehandlingService: NotatTilbakekrevingsbehandlingService, + annullerKravgrunnlagService: AnnullerKravgrunnlagService, ) { this.opprettTilbakekrevingsbehandlingRoute(opprettTilbakekrevingsbehandlingService) this.vurderTilbakekrevingsbehandlingRoute(månedsvurderingerTilbakekrevingsbehandlingService) @@ -57,4 +60,5 @@ fun Route.tilbakekrevingRoutes( this.avbrytTilbakekrevingsbehandlingRoute(avbrytTilbakekrevingsbehandlingService) this.oppdaterKravgrunnlagRoute(oppdaterKravgrunnlagService) this.notatTilbakekrevingsbehandlingRoute(notatTilbakekrevingsbehandlingService) + this.annullerKravgrunnlagRoute(annullerKravgrunnlagService) } diff --git a/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/kravgrunnlag/AnnullerKravgrunnlagRoute.kt b/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/kravgrunnlag/AnnullerKravgrunnlagRoute.kt new file mode 100644 index 0000000000..b411197886 --- /dev/null +++ b/tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/kravgrunnlag/AnnullerKravgrunnlagRoute.kt @@ -0,0 +1,107 @@ +package tilbakekreving.presentation.api.kravgrunnlag + +import io.ktor.http.HttpStatusCode +import io.ktor.server.application.call +import io.ktor.server.routing.Route +import io.ktor.server.routing.patch +import no.nav.su.se.bakover.common.brukerrolle.Brukerrolle +import no.nav.su.se.bakover.common.infrastructure.web.Resultat +import no.nav.su.se.bakover.common.infrastructure.web.authorize +import no.nav.su.se.bakover.common.infrastructure.web.correlationId +import no.nav.su.se.bakover.common.infrastructure.web.errorJson +import no.nav.su.se.bakover.common.infrastructure.web.lesUUID +import no.nav.su.se.bakover.common.infrastructure.web.suUserContext +import no.nav.su.se.bakover.common.infrastructure.web.svar +import no.nav.su.se.bakover.common.infrastructure.web.withBody +import no.nav.su.se.bakover.common.infrastructure.web.withSakId +import no.nav.su.se.bakover.common.serialize +import no.nav.su.se.bakover.hendelse.domain.HendelseId +import no.nav.su.se.bakover.hendelse.domain.Hendelsesversjon +import tilbakekreving.application.service.kravgrunnlag.AnnullerKravgrunnlagService +import tilbakekreving.application.service.kravgrunnlag.KunneIkkeAnnullereKravgrunnlag +import tilbakekreving.domain.kravgrunnlag.AnnullerKravgrunnlagCommand +import tilbakekreving.presentation.api.TILBAKEKREVING_PATH +import tilbakekreving.presentation.api.common.KravgrunnlagJson +import tilbakekreving.presentation.api.common.TilbakekrevingsbehandlingJson +import tilbakekreving.presentation.api.common.TilbakekrevingsbehandlingJson.Companion.toJson +import tilbakekreving.presentation.api.common.ikkeTilgangTilSak + +internal fun Route.annullerKravgrunnlagRoute( + service: AnnullerKravgrunnlagService, +) { + data class Body(val versjon: Long) + + patch("$TILBAKEKREVING_PATH/kravgrunnlag/{kravgrunnlagHendelseId}/annuller") { + authorize(Brukerrolle.Saksbehandler, Brukerrolle.Attestant) { + call.withSakId { sakId -> + call.lesUUID("kravgrunnlagHendelseId").fold( + ifLeft = { + call.svar( + HttpStatusCode.BadRequest.errorJson( + it, + "kravgrunnlagHendelseId_mangler_eller_feil_format", + ), + ) + }, + ifRight = { kravgrunnlagHendelseId -> + call.withBody { + service.annuller( + command = AnnullerKravgrunnlagCommand( + sakId = sakId, + correlationId = call.correlationId, + brukerroller = call.suUserContext.roller, + annullertAv = call.suUserContext.saksbehandler, + kravgrunnlagHendelseId = HendelseId.fromUUID(kravgrunnlagHendelseId), + klientensSisteSaksversjon = Hendelsesversjon(it.versjon), + ), + ).fold( + ifLeft = { call.svar(it.tilResultat()) }, + ifRight = { + call.svar( + Resultat.json( + HttpStatusCode.OK, + serialize(AnnullertKravgrunnlagJson(tilbakekrevingsbehandling = it?.toJson())), + ), + ) + }, + ) + } + }, + ) + } + } + } +} + +data class AnnullertKravgrunnlagJson( + val uteståendeKravgrunnlag: KravgrunnlagJson? = null, + val tilbakekrevingsbehandling: TilbakekrevingsbehandlingJson?, +) + +internal fun KunneIkkeAnnullereKravgrunnlag.tilResultat(): Resultat = when (this) { + is KunneIkkeAnnullereKravgrunnlag.IkkeTilgang -> ikkeTilgangTilSak + KunneIkkeAnnullereKravgrunnlag.BehandlingenErIFeilTilstandForÅAnnullere -> HttpStatusCode.BadRequest.errorJson( + "Behandlingen er i en tilstand som ikke tillater å annullere kravgrunnlaget", + "feil_tilstand_for_å_annullere_kravgrunnlag", + ) + + KunneIkkeAnnullereKravgrunnlag.FantIkkeKravgrunnlag -> HttpStatusCode.BadRequest.errorJson( + "Fant ikke kravgrunnlag", + "fant_ikke_kravgrunnlag", + ) + + is KunneIkkeAnnullereKravgrunnlag.FeilMotTilbakekrevingskomponenten -> HttpStatusCode.InternalServerError.errorJson( + "Teknisk feil mot tilbakekrevingskomponenten", + "teknisk_feil_tilbakekrevingskomponent", + ) + + KunneIkkeAnnullereKravgrunnlag.InnsendtHendelseIdErIkkeDenSistePåSaken -> HttpStatusCode.BadRequest.errorJson( + "Innsendt hendelseId for kravgrunnlaget er ikke den siste på saken", + "hendelseId_er_ikke_siste_på_saken", + ) + + KunneIkkeAnnullereKravgrunnlag.SakenHarIkkeKravgrunnlagSomKanAnnulleres -> HttpStatusCode.BadRequest.errorJson( + "Saken har ikke kravgrunnlag som kan annulleres", + "saken_har_ikke_kravgrunnlag_som_kan_annulleres", + ) +} diff --git a/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/kravgrunnlag/KravgrunnlagHelpers.kt b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/kravgrunnlag/KravgrunnlagHelpers.kt index 5fd49500f3..7eb9a5f41c 100644 --- a/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/kravgrunnlag/KravgrunnlagHelpers.kt +++ b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/kravgrunnlag/KravgrunnlagHelpers.kt @@ -2,6 +2,7 @@ package no.nav.su.se.bakover.web.kravgrunnlag import no.nav.su.se.bakover.common.CorrelationId import no.nav.su.se.bakover.common.UUID30 +import no.nav.su.se.bakover.hendelse.domain.HendelseId import no.nav.su.se.bakover.hendelse.domain.JMSHendelseMetadata import no.nav.su.se.bakover.test.kravgrunnlag.kravgrunnlagStatusendringXml import no.nav.su.se.bakover.web.komponenttest.AppComponents @@ -14,7 +15,7 @@ import tilbakekreving.presentation.Tilbakekrevingskomponenter */ internal fun AppComponents.emulerViMottarKravgrunnlagDetaljer( overstyrUtbetalingId: List? = null, -) { +): List { // Emulerer at det kommer detaljer på køen som matcher revurderingen sin simulering. lagreRåttKravgrunnlagDetaljerForUtbetalingerSomMangler( sessionFactory = this.databaseRepos.sessionFactory, @@ -25,7 +26,10 @@ internal fun AppComponents.emulerViMottarKravgrunnlagDetaljer( // Siden vi ikke kjører jobbene i test-miljøet må vi også kjøre denne konsumenten. this.tilbakekrevingskomponenter.services.knyttKravgrunnlagTilSakOgUtbetalingKonsument.knyttKravgrunnlagTilSakOgUtbetaling( correlationId = CorrelationId.generate(), - ) + ).map { + return it + } + return emptyList() } internal fun AppComponents.emulerViMottarKravgrunnlagstatusendring( diff --git a/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AnnullerKravgrunnlag.kt b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AnnullerKravgrunnlag.kt new file mode 100644 index 0000000000..bcd07f73e3 --- /dev/null +++ b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AnnullerKravgrunnlag.kt @@ -0,0 +1,104 @@ +package no.nav.su.se.bakover.web.tilbakekreving + +import io.kotest.assertions.withClue +import io.kotest.matchers.shouldBe +import io.ktor.client.HttpClient +import io.ktor.client.request.setBody +import io.ktor.client.statement.bodyAsText +import io.ktor.http.HttpMethod +import io.ktor.http.HttpStatusCode +import kotlinx.coroutines.runBlocking +import no.nav.su.se.bakover.common.brukerrolle.Brukerrolle +import no.nav.su.se.bakover.test.json.shouldBeSimilarJsonTo +import no.nav.su.se.bakover.web.komponenttest.AppComponents + +internal data class AnnullerKravgrunnlagTilbakekrevingsbehandlingVerifikasjon( + val behandlingsId: String, + val sakId: String, + val kravgrunnlagHendelseId: String, +) + +internal fun AppComponents.annullerKravgrunnlag( + sakId: String, + kravgrunnlagHendelseId: String, + client: HttpClient, + saksversjon: Long, + expectedHttpStatusCode: HttpStatusCode = HttpStatusCode.OK, + verifiserBehandling: AnnullerKravgrunnlagTilbakekrevingsbehandlingVerifikasjon? = null, +): AnnullerKravgrunnlagResponse { + return runBlocking { + no.nav.su.se.bakover.test.application.defaultRequest( + method = HttpMethod.Patch, + uri = "/saker/$sakId/tilbakekreving/kravgrunnlag/$kravgrunnlagHendelseId/annuller", + listOf(Brukerrolle.Saksbehandler), + client = client, + ) { + setBody("""{"versjon": $saksversjon}""") + }.apply { + withClue("Kunne ikke annullere kravgrunnlag: ${this.bodyAsText()}") { + status shouldBe expectedHttpStatusCode + } + }.bodyAsText().let { responseJson -> + verifiserResponse(responseJson, verifiserBehandling) + + AnnullerKravgrunnlagResponse( + saksversjon = saksversjon.inc(), + responseJson = responseJson, + ) + } + } +} + +data class AnnullerKravgrunnlagResponse( + val saksversjon: Long, + val responseJson: String, +) + +internal fun verifiserResponse( + actual: String, + verifiserBehandling: AnnullerKravgrunnlagTilbakekrevingsbehandlingVerifikasjon? = null, +) { + val expected = if (verifiserBehandling != null) { + """{ + "id":"${verifiserBehandling.behandlingsId}", + "sakId":"${verifiserBehandling.sakId}", + "opprettet":"2021-02-01T01:03:47.456789Z", + "opprettetAv":"Z990Lokal", + "kravgrunnlag":{ + "hendelseId":${verifiserBehandling.kravgrunnlagHendelseId}, + "eksternKravgrunnlagsId":"123456", + "eksternVedtakId":"654321", + "kontrollfelt":"2021-02-01-02.03.42.456789", + "status":"NY", + "grunnlagsperiode":[{"periode":{"fraOgMed":"2021-01-01","tilOgMed":"2021-01-31"},"betaltSkattForYtelsesgruppen":"1192","bruttoTidligereUtbetalt":"10946","bruttoNyUtbetaling":"8563","bruttoFeilutbetaling":"2383","nettoFeilutbetaling":"1191","skatteProsent":"50","skattFeilutbetaling":"1192"}], + "summertBetaltSkattForYtelsesgruppen":"1192", + "summertBruttoTidligereUtbetalt":10946, + "summertBruttoNyUtbetaling":8563, + "summertBruttoFeilutbetaling":2383, + "summertNettoFeilutbetaling":1191, + "summertSkattFeilutbetaling":1192 + }, + "status":"AVBRUTT", + "vurderinger":null, + "fritekst":null, + "forhåndsvarselsInfo":[], + "versjon":8, + "sendtTilAttesteringAv":null, + "attesteringer":[], + "erKravgrunnlagUtdatert":false, + "avsluttetTidspunkt":"2021-02-01T01:03:51.456789Z", + "notat":null + } + """.trimIndent() + } else { + null + } + + actual.shouldBeSimilarJsonTo( + """{ + "uteståendeKravgrunnlag": null, + "tilbakekrevingsbehandling": $expected + } + """.trimIndent(), + ) +} diff --git a/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AnnullerKravgrunnlagIT.kt b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AnnullerKravgrunnlagIT.kt new file mode 100644 index 0000000000..ea25d13dda --- /dev/null +++ b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/AnnullerKravgrunnlagIT.kt @@ -0,0 +1,112 @@ +package no.nav.su.se.bakover.web.tilbakekreving + +import io.kotest.matchers.shouldBe +import no.nav.su.se.bakover.common.domain.tid.februar +import no.nav.su.se.bakover.common.domain.tid.januar +import no.nav.su.se.bakover.common.person.Fnr +import no.nav.su.se.bakover.test.TikkendeKlokke +import no.nav.su.se.bakover.test.fixedClockAt +import no.nav.su.se.bakover.test.generer +import no.nav.su.se.bakover.web.SharedRegressionTestData +import no.nav.su.se.bakover.web.kravgrunnlag.emulerViMottarKravgrunnlagDetaljer +import no.nav.su.se.bakover.web.revurdering.opprettIverksattRevurdering +import no.nav.su.se.bakover.web.søknadsbehandling.BehandlingJson +import no.nav.su.se.bakover.web.søknadsbehandling.RevurderingJson +import no.nav.su.se.bakover.web.søknadsbehandling.opprettInnvilgetSøknadsbehandling +import org.junit.jupiter.api.Test + +internal class AnnullerKravgrunnlagIT { + + @Test + fun `annullerer kravgrunnlag uten tilbakekrevingsbehandling`() { + val clock = TikkendeKlokke(fixedClockAt(1.februar(2021))) + SharedRegressionTestData.withTestApplicationAndEmbeddedDb( + clock = clock, + ) { appComponents -> + val stønadStart = 1.januar(2021) + val stønadSlutt = 31.januar(2021) + val fnr = Fnr.generer().toString() + val søknadsbehandlingJson = opprettInnvilgetSøknadsbehandling( + fnr = fnr, + fraOgMed = stønadStart.toString(), + tilOgMed = stønadSlutt.toString(), + client = this.client, + appComponents = appComponents, + ) + val sakId = BehandlingJson.hentSakId(søknadsbehandlingJson) + opprettIverksattRevurdering( + sakid = sakId, + fraogmed = 1.januar(2021).toString(), + tilogmed = 31.januar(2021).toString(), + client = this.client, + appComponents = appComponents, + ).let { + RevurderingJson.hentRevurderingId(it) + } + val kravgrunnlagHendelser = appComponents.emulerViMottarKravgrunnlagDetaljer().also { + it.size shouldBe 1 + } + // 1. reservert, 2. kvittering søknadsbehandling 3. kvittering revurdering 4. kravgrunnlag + appComponents.annullerKravgrunnlag( + sakId = sakId, + kravgrunnlagHendelseId = kravgrunnlagHendelser.first().toString(), + saksversjon = 5, + client = this.client, + ) + hentKravgrunnlagPåSak(sakId, client) shouldBe null + } + } + + @Test + fun `annullerer kravgrunnlag som har en aktiv tilbakekrevingsbehandling`() { + val clock = TikkendeKlokke(fixedClockAt(1.februar(2021))) + SharedRegressionTestData.withTestApplicationAndEmbeddedDb( + clock = clock, + ) { appComponents -> + val stønadStart = 1.januar(2021) + val stønadSlutt = 31.januar(2021) + val fnr = Fnr.generer().toString() + val søknadsbehandlingJson = opprettInnvilgetSøknadsbehandling( + fnr = fnr, + fraOgMed = stønadStart.toString(), + tilOgMed = stønadSlutt.toString(), + client = this.client, + appComponents = appComponents, + ) + val sakId = BehandlingJson.hentSakId(søknadsbehandlingJson) + opprettIverksattRevurdering( + sakid = sakId, + fraogmed = 1.januar(2021).toString(), + tilogmed = 31.januar(2021).toString(), + client = this.client, + appComponents = appComponents, + ).let { + RevurderingJson.hentRevurderingId(it) + } + val kravgrunnlagHendelser = appComponents.emulerViMottarKravgrunnlagDetaljer().also { + it.size shouldBe 1 + } + // 1. reservert, 2. kvittering søknadsbehandling 3. kvittering revurdering 4. kravgrunnlag + verifiserKravgrunnlagPåSak(sakId, client, true, 4) + val (tilbakekrevingsbehandlingId, saksversjonEtterOpprettelseAvBehandling) = appComponents.opprettTilbakekrevingsbehandling( + sakId = sakId, + // Må økes etter hvert som vi får flere hendelser. + saksversjon = 4, + client = this.client, + expectedKontrollfelt = "2021-02-01-02.03.42.456789", + ) + appComponents.annullerKravgrunnlag( + sakId = sakId, + kravgrunnlagHendelseId = kravgrunnlagHendelser.first().toString(), + saksversjon = saksversjonEtterOpprettelseAvBehandling.inc(), + client = this.client, + verifiserBehandling = AnnullerKravgrunnlagTilbakekrevingsbehandlingVerifikasjon( + behandlingsId = tilbakekrevingsbehandlingId, + sakId = sakId, + kravgrunnlagHendelseId = kravgrunnlagHendelser.first().toString(), + ), + ) + hentKravgrunnlagPåSak(sakId, client) shouldBe null + } + } +} diff --git a/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/TilbakekrevingHelpers.kt b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/TilbakekrevingHelpers.kt index 0593c18af3..6757bb735f 100644 --- a/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/TilbakekrevingHelpers.kt +++ b/web-regresjonstest/src/test/kotlin/no/nav/su/se/bakover/web/tilbakekreving/TilbakekrevingHelpers.kt @@ -379,3 +379,16 @@ internal fun verifiserKravgrunnlagPåSak( JSONObject(sakJson).getInt("versjon") shouldBe versjon } } + +internal fun hentKravgrunnlagPåSak( + sakId: String, + client: HttpClient, +): String? { + return hentSak(sakId, client = client).let { + if (JSONObject(it).isNull("uteståendeKravgrunnlag")) { + null + } else { + JSONObject(it).getJSONObject("uteståendeKravgrunnlag").toString() + } + } +} diff --git a/web/src/main/kotlin/no/nav/su/se/bakover/web/Routes.kt b/web/src/main/kotlin/no/nav/su/se/bakover/web/Routes.kt index e9f55dda0f..21f527acd6 100644 --- a/web/src/main/kotlin/no/nav/su/se/bakover/web/Routes.kt +++ b/web/src/main/kotlin/no/nav/su/se/bakover/web/Routes.kt @@ -154,6 +154,7 @@ internal fun Application.setupKtorRoutes( avbrytTilbakekrevingsbehandlingService = tilbakekrevingskomponenter.services.avbrytTilbakekrevingsbehandlingService, oppdaterKravgrunnlagService = tilbakekrevingskomponenter.services.oppdaterKravgrunnlagService, notatTilbakekrevingsbehandlingService = tilbakekrevingskomponenter.services.notatTilbakekrevingsbehandlingService, + annullerKravgrunnlagService = tilbakekrevingskomponenter.services.annullerKravgrunnlagService, ) økonomiRoutes(resendUtbetalingService) vedtakRoutes(services.vedtakService, formuegrenserFactoryIDag)