diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/BehandlingController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/BehandlingController.kt index dda28d14a..4a85e028a 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/BehandlingController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/BehandlingController.kt @@ -8,6 +8,7 @@ import no.nav.familie.kontrakter.felles.tilbakekreving.OpprettTilbakekrevingRequ import no.nav.familie.tilbake.api.dto.BehandlingDto import no.nav.familie.tilbake.api.dto.BehandlingPåVentDto import no.nav.familie.tilbake.api.dto.BehandlingsstegDto +import no.nav.familie.tilbake.api.dto.BehandlingsstegFatteVedtaksstegDto import no.nav.familie.tilbake.api.dto.ByttEnhetDto import no.nav.familie.tilbake.api.dto.HenleggelsesbrevFritekstDto import no.nav.familie.tilbake.api.dto.OpprettRevurderingDto @@ -21,8 +22,8 @@ import no.nav.familie.tilbake.forvaltning.ForvaltningService import no.nav.familie.tilbake.log.SecureLog import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.familie.tilbake.sikkerhet.TilgangService import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.HttpStatus @@ -47,6 +48,7 @@ class BehandlingController( private val forvaltningService: ForvaltningService, private val behandlingskontrollService: BehandlingskontrollService, private val tilgangService: TilgangService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Opprett tilbakekrevingsbehandling automatisk, kan kalles av fagsystem, batch") @PostMapping( @@ -98,33 +100,39 @@ class BehandlingController( path = ["/v1/{behandlingId}"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - minimumBehandlerrolle = Behandlerrolle.VEILEDER, - handling = "Henter tilbakekrevingsbehandling", - AuditLoggerEvent.ACCESS, - henteParam = HenteParam.BEHANDLING_ID, - ) fun hentBehandling( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(behandlingService.hentBehandling(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter tilbakekrevingsbehandling", + ) + return Ressurs.success(behandlingService.hentBehandling(behandlingId)) + } @Operation(summary = "Utfør behandlingssteg og fortsett behandling til neste steg") @PostMapping( path = ["{behandlingId}/steg/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - // Rollen blir endret til BESLUTTER i Tilgangskontroll for FatteVedtak steg - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Utfører behandlingens aktiv steg og fortsetter den til neste steg", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun utførBehandlingssteg( @PathVariable("behandlingId") behandlingId: UUID, @Valid @RequestBody behandlingsstegDto: BehandlingsstegDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = + if (behandlingsstegDto is BehandlingsstegFatteVedtaksstegDto) { + Behandlerrolle.BESLUTTER + } else { + Behandlerrolle.SAKSBEHANDLER + }, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Utfører behandlingens aktiv steg og fortsetter den til neste steg", + ) // Oppdaterer ansvarlig saksbehandler først slik at historikkinnslag får riktig saksbehandler // Hvis det feiler noe,bør det rullet tilbake helt siden begge 2 er på samme transaksjon if (stegService.kanAnsvarligSaksbehandlerOppdateres(behandlingId, behandlingsstegDto)) { @@ -141,17 +149,17 @@ class BehandlingController( path = ["{behandlingId}/vent/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Setter saksbehandler behandling på vent eller utvider fristen", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun settBehandlingPåVent( @PathVariable("behandlingId") behandlingId: UUID, @Valid @RequestBody behandlingPåVentDto: BehandlingPåVentDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Setter saksbehandler behandling på vent eller utvider fristen", + ) behandlingService.settBehandlingPåVent(behandlingId, behandlingPåVentDto) return Ressurs.success("OK") } @@ -161,15 +169,15 @@ class BehandlingController( path = ["{behandlingId}/gjenoppta/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Saksbehandler tar behandling av vent etter å motta brukerrespons eller dokumentasjon", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun taBehandlingAvVent( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Saksbehandler tar behandling av vent etter å motta brukerrespons eller dokumentasjon", + ) behandlingService.taBehandlingAvvent(behandlingId) return Ressurs.success("OK") } @@ -179,17 +187,17 @@ class BehandlingController( path = ["{behandlingId}/henlegg/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Saksbehandler henlegger behandling", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun henleggBehandling( @PathVariable("behandlingId") behandlingId: UUID, @Valid @RequestBody henleggelsesbrevFritekstDto: HenleggelsesbrevFritekstDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Saksbehandler henlegger behandling", + ) behandlingService.henleggBehandling(behandlingId, henleggelsesbrevFritekstDto) return Ressurs.success("OK") } @@ -199,17 +207,17 @@ class BehandlingController( path = ["{behandlingId}/bytt-enhet/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Saksbehandler bytter enhet på behandling", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun byttEnhet( @PathVariable("behandlingId") behandlingId: UUID, @Valid @RequestBody byttEnhetDto: ByttEnhetDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Saksbehandler bytter enhet på behandling", + ) behandlingService.byttBehandlendeEnhet(behandlingId, byttEnhetDto) return Ressurs.success("OK") } @@ -219,15 +227,15 @@ class BehandlingController( path = ["{behandlingId}/angre-send-til-beslutter"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Saksbehandler angrer på send til beslutter og tar behandling tilbake til saksbehandler", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun angreSendTilBeslutter( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Saksbehandler angrer på send til beslutter og tar behandling tilbake til saksbehandler", + ) behandlingService.angreSendTilBeslutter(behandlingId) return Ressurs.success("OK") } @@ -237,15 +245,15 @@ class BehandlingController( path = ["{behandlingId}/flytt-behandling-til-fakta"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Flytter behandling tilbake til Fakta", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun flyttBehandlingTilFakta( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Flytter behandling tilbake til Fakta", + ) val behandling = behandlingService.hentBehandling(behandlingId) val logContext = SecureLog.Context.medBehandling(behandling.eksternFagsakId, behandling.behandlingId.toString()) validerKanSetteBehandlingTilbakeTilFakta(behandling, logContext) diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/BeregningController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/BeregningController.kt index b3e72cf02..fed8549ef 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/BeregningController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/BeregningController.kt @@ -9,8 +9,7 @@ import no.nav.familie.tilbake.api.dto.BeregningsresultatDto import no.nav.familie.tilbake.beregning.TilbakekrevingsberegningService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -28,36 +27,41 @@ import java.util.UUID @Validated class BeregningController( val tilbakekrevingsberegningService: TilbakekrevingsberegningService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Beregn feilutbetalt beløp for nye delte perioder") @PostMapping( path = ["{behandlingId}/beregn/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, - handling = "Beregner feilutbetalt beløp for nye delte perioder", - AuditLoggerEvent.ACCESS, - henteParam = HenteParam.BEHANDLING_ID, - ) fun beregnBeløp( @PathVariable("behandlingId") behandlingId: UUID, @Valid @RequestBody perioder: List, - ): Ressurs = Ressurs.success(tilbakekrevingsberegningService.beregnBeløp(behandlingId, perioder)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Beregner feilutbetalt beløp for nye delte perioder", + ) + return Ressurs.success(tilbakekrevingsberegningService.beregnBeløp(behandlingId, perioder)) + } @Operation(summary = "Hent beregningsresultat") @GetMapping( path = ["{behandlingId}/beregn/resultat/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - minimumBehandlerrolle = Behandlerrolle.VEILEDER, - handling = "Henter beregningsresultat", - AuditLoggerEvent.ACCESS, - henteParam = HenteParam.BEHANDLING_ID, - ) fun hentBeregningsresultat( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(tilbakekrevingsberegningService.hentBeregningsresultat(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter beregningsresultat", + ) + return Ressurs.success(tilbakekrevingsberegningService.hentBeregningsresultat(behandlingId)) + } } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/DokumentController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/DokumentController.kt index 36986ce14..65092ee87 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/DokumentController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/DokumentController.kt @@ -17,8 +17,8 @@ import no.nav.familie.tilbake.dokumentbestilling.vedtak.Avsnitt import no.nav.familie.tilbake.dokumentbestilling.vedtak.VedtaksbrevService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.web.bind.annotation.GetMapping @@ -38,6 +38,7 @@ class DokumentController( private val henleggelsesbrevService: HenleggelsesbrevService, private val vedtaksbrevService: VedtaksbrevService, private val lagreUtkastVedtaksbrevService: LagreUtkastVedtaksbrevService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Bestill brevsending") @PostMapping("/bestill") @@ -105,26 +106,33 @@ class DokumentController( "/vedtaksbrevtekst/{behandlingId}", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk(Behandlerrolle.VEILEDER, "Henter vedtaksbrevtekst", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) fun hentVedtaksbrevtekst( @PathVariable behandlingId: UUID, - ): Ressurs> = Ressurs.success(vedtaksbrevService.hentVedtaksbrevSomTekst(behandlingId)) + ): Ressurs> { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter vedtaksbrevtekst", + ) + return Ressurs.success(vedtaksbrevService.hentVedtaksbrevSomTekst(behandlingId)) + } @Operation(summary = "Lagre utkast av vedtaksbrev") @PostMapping( "/vedtaksbrevtekst/{behandlingId}/utkast", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Lagrer utkast av vedtaksbrev", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun lagreUtkastVedtaksbrev( @PathVariable behandlingId: UUID, @RequestBody fritekstavsnitt: FritekstavsnittDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Lagrer utkast av vedtaksbrev", + ) lagreUtkastVedtaksbrevService.lagreUtkast(behandlingId, fritekstavsnitt) return Ressurs.success("OK") } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/FaktaFeilutbetalingController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/FaktaFeilutbetalingController.kt index 77273f734..9092a3db8 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/FaktaFeilutbetalingController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/FaktaFeilutbetalingController.kt @@ -7,8 +7,7 @@ import no.nav.familie.tilbake.api.dto.FaktaFeilutbetalingDto import no.nav.familie.tilbake.faktaomfeilutbetaling.FaktaFeilutbetalingService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -24,38 +23,43 @@ import java.util.UUID @Validated class FaktaFeilutbetalingController( val faktaFeilutbetalingService: FaktaFeilutbetalingService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Hent fakta om feilutbetaling") @GetMapping( path = ["/behandling/{behandlingId}/fakta/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter fakta om feilutbetaling for en gitt behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentFaktaomfeilutbetaling( @NotNull @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(faktaFeilutbetalingService.hentFaktaomfeilutbetaling(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId, + Behandlerrolle.VEILEDER, + AuditLoggerEvent.ACCESS, + "Henter fakta om feilutbetaling for en gitt behandling", + ) + return Ressurs.success(faktaFeilutbetalingService.hentFaktaomfeilutbetaling(behandlingId)) + } @Operation(summary = "Hent inaktive fakta om feilutbetalinger") @GetMapping( path = ["/behandling/{behandlingId}/fakta/inaktiv"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter inaktive fakta om feilutbetaling for en gitt behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentInaktivFaktaomfeilutbetaling( @NotNull @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs> = Ressurs.success(faktaFeilutbetalingService.hentInaktivFaktaomfeilutbetaling(behandlingId)) + ): Ressurs> { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter inaktive fakta om feilutbetaling for en gitt behandling", + ) + return Ressurs.success(faktaFeilutbetalingService.hentInaktivFaktaomfeilutbetaling(behandlingId)) + } } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/ForeldelseController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/ForeldelseController.kt index ac48d3eb8..5d48f4c03 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/ForeldelseController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/ForeldelseController.kt @@ -6,8 +6,7 @@ import no.nav.familie.tilbake.api.dto.VurdertForeldelseDto import no.nav.familie.tilbake.foreldelse.ForeldelseService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -23,19 +22,22 @@ import java.util.UUID @Validated class ForeldelseController( val foreldelseService: ForeldelseService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Hent foreldelsesinformasjon") @GetMapping( path = ["{behandlingId}/foreldelse/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter foreldelsesinformasjon for en gitt behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentVurdertForeldelse( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(foreldelseService.hentVurdertForeldelse(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter foreldelsesinformasjon for en gitt behandling", + ) + return Ressurs.success(foreldelseService.hentVurdertForeldelse(behandlingId)) + } } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/HistorikkController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/HistorikkController.kt index b6311f033..20432cc39 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/HistorikkController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/HistorikkController.kt @@ -6,8 +6,7 @@ import no.nav.familie.tilbake.api.dto.tilDto import no.nav.familie.tilbake.historikkinnslag.HistorikkService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -23,20 +22,21 @@ import java.util.UUID @Validated class HistorikkController( private val historikkService: HistorikkService, + private val tilgangAdvice: TilgangAdvice, ) { @GetMapping( "/{behandlingId}/historikk", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - minimumBehandlerrolle = Behandlerrolle.VEILEDER, - handling = "Henter historikkinnslag", - AuditLoggerEvent.ACCESS, - henteParam = HenteParam.BEHANDLING_ID, - ) fun hentHistorikkinnslag( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs> { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter historikkinnslag", + ) val historikkInnslagDtoSortertEtterOpprettetTidspunkt = historikkService .hentHistorikkinnslag(behandlingId) diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/JournalpostController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/JournalpostController.kt index 06744708b..c8bef13b1 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/JournalpostController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/JournalpostController.kt @@ -6,8 +6,7 @@ import no.nav.familie.kontrakter.felles.journalpost.Journalpost import no.nav.familie.tilbake.dokumentbestilling.felles.pdf.JournalføringService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.validation.annotation.Validated import org.springframework.web.bind.annotation.GetMapping @@ -22,20 +21,35 @@ import java.util.UUID @Validated class JournalpostController( private val journalføringService: JournalføringService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Hent dokument fra journalføring") @GetMapping("/{behandlingId}/journalpost/{journalpostId}/dokument/{dokumentInfoId}") - @Rolletilgangssjekk(Behandlerrolle.VEILEDER, "Henter journalført dokument", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) fun hentDokument( @PathVariable behandlingId: UUID, @PathVariable journalpostId: String, @PathVariable dokumentInfoId: String, - ): Ressurs = Ressurs.success(journalføringService.hentDokument(journalpostId, dokumentInfoId), "OK") + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter journalført dokument", + ) + return Ressurs.success(journalføringService.hentDokument(journalpostId, dokumentInfoId), "OK") + } @Operation(summary = "Hent journalpost informasjon") @GetMapping("/{behandlingId}/journalposter") - @Rolletilgangssjekk(Behandlerrolle.VEILEDER, "Henter journalført dokument", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) fun hentJournalposter( @PathVariable behandlingId: UUID, - ): Ressurs> = Ressurs.success(journalføringService.hentJournalposter(behandlingId)) + ): Ressurs> { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter journalført dokument", + ) + return Ressurs.success(journalføringService.hentJournalposter(behandlingId)) + } } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/ManuellBrevmottakerController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/ManuellBrevmottakerController.kt index 5e6c38f32..413b6e5d0 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/ManuellBrevmottakerController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/ManuellBrevmottakerController.kt @@ -9,8 +9,8 @@ import no.nav.familie.tilbake.dokumentbestilling.manuell.brevmottaker.ManuellBre import no.nav.familie.tilbake.dokumentbestilling.manuell.brevmottaker.ManuellBrevmottakerService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -30,6 +30,7 @@ import java.util.UUID @Validated class ManuellBrevmottakerController( private val manuellBrevmottakerService: ManuellBrevmottakerService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Legger til brevmottaker manuelt") @PostMapping( @@ -37,17 +38,17 @@ class ManuellBrevmottakerController( consumes = [MediaType.APPLICATION_JSON_VALUE], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Legger til brevmottaker manuelt", - AuditLoggerEvent.CREATE, - HenteParam.BEHANDLING_ID, - ) fun leggTilBrevmottaker( @PathVariable behandlingId: UUID, @Valid @RequestBody manuellBrevmottakerRequestDto: ManuellBrevmottakerRequestDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.CREATE, + handling = "Legger til brevmottaker manuelt", + ) val id = manuellBrevmottakerService.leggTilBrevmottaker(behandlingId, manuellBrevmottakerRequestDto) return Ressurs.success(id, melding = "Manuell brevmottaker er lagt til.") } @@ -57,21 +58,22 @@ class ManuellBrevmottakerController( path = ["/{behandlingId}"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, - handling = "Henter manuelle brevmottakere", - auditLoggerEvent = AuditLoggerEvent.ACCESS, - henteParam = HenteParam.BEHANDLING_ID, - ) fun hentManuellBrevmottakere( @PathVariable behandlingId: UUID, - ): Ressurs> = - Ressurs + ): Ressurs> { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter manuelle brevmottakere", + ) + return Ressurs .success( manuellBrevmottakerService .hentBrevmottakere(behandlingId) .map { ManuellBrevmottakerMapper.tilRespons(it) }, ) + } @Operation(summary = "Oppdaterer manuell brevmottaker") @PutMapping( @@ -79,18 +81,18 @@ class ManuellBrevmottakerController( consumes = [MediaType.APPLICATION_JSON_VALUE], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Oppdaterer manuell brevmottaker", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun oppdaterManuellBrevmottaker( @PathVariable behandlingId: UUID, @PathVariable manuellBrevmottakerId: UUID, @Valid @RequestBody manuellBrevmottakerRequestDto: ManuellBrevmottakerRequestDto, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Oppdaterer manuell brevmottaker", + ) manuellBrevmottakerService.oppdaterBrevmottaker(behandlingId, manuellBrevmottakerId, manuellBrevmottakerRequestDto) return Ressurs.success("", melding = "Manuell brevmottaker er oppdatert") } @@ -112,30 +114,30 @@ class ManuellBrevmottakerController( @Operation(summary = "Opprett og aktiver brevmottaker-steg på behandling") @PostMapping(path = ["/{behandlingId}/aktiver"]) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Oppretter brevmottaker-steg på behandling", - AuditLoggerEvent.CREATE, - HenteParam.BEHANDLING_ID, - ) fun opprettBrevmottakerSteg( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.CREATE, + handling = "Oppretter brevmottaker-steg på behandling", + ) manuellBrevmottakerService.opprettBrevmottakerSteg(behandlingId) return Ressurs.success("OK") } @Operation(summary = "Fjern manuelle brevmottakere og deaktiver steg") @PutMapping(path = ["/{behandlingId}/deaktiver"]) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Fjern ev. manuelt registrerte brevmottakere og deaktiver steg.", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun fjernBrevmottakerSteg( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Fjern ev. manuelt registrerte brevmottakere og deaktiver steg.", + ) manuellBrevmottakerService.fjernManuelleBrevmottakereOgTilbakeførSteg(behandlingId) return Ressurs.success("OK") } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/PerioderController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/PerioderController.kt index 1e0caa5df..206762c3b 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/PerioderController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/PerioderController.kt @@ -10,8 +10,7 @@ import no.nav.familie.tilbake.dokumentbestilling.vedtak.Vedtaksbrevsoppsummering import no.nav.familie.tilbake.dokumentbestilling.vedtak.domain.SkalSammenslåPerioder import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.web.bind.annotation.GetMapping @@ -29,21 +28,22 @@ class PerioderController( private val vedtaksbrevsoppsummeringRepository: VedtaksbrevsoppsummeringRepository, private val fagsakRepository: FagsakRepository, private val periodeService: PeriodeService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Sjekker om perioder er like - unntatt dato og beløp") @GetMapping( "/sjekk-likhet/{behandlingId}", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Sjekker om perioder er like - unntatt dato og beløp", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun erPerioderLike( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Sjekker om perioder er like - unntatt dato og beløp", + ) val erEnsligForsørgerOgPerioderLike = periodeService.erEnsligForsørgerOgPerioderLike(behandlingId) return Ressurs.success( erEnsligForsørgerOgPerioderLike == SkalSammenslåPerioder.JA, @@ -55,15 +55,15 @@ class PerioderController( "/hent-sammenslatt/{behandlingId}", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Sjekker om perioder er sammenslått", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun erPerioderSammenslått( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Sjekker om perioder er sammenslått", + ) val erPerioderSammenslått = periodeService.erPerioderSammenslått(behandlingId) return Ressurs.success( erPerioderSammenslått, @@ -75,15 +75,15 @@ class PerioderController( "/sammensla/{behandlingId}", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Oppdatere skalSammenslåPerioder", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun sammenslå( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Oppdatere skalSammenslåPerioder", + ) val behandling = fagsakRepository.finnFagsakForBehandlingId(behandlingId) if (behandling.ytelsestype.tilTema() != Tema.ENF) { throw Exception("Kan ikke slå sammen perioder i behandling som ikke er for en enslig forsørger ytelse") @@ -97,15 +97,15 @@ class PerioderController( "/angre-sammenslaing/{behandlingId}", produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Angre sammenslåing av perioder", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun angreSammenslåing( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Angre sammenslåing av perioder", + ) val vedtaksbrevsoppsummering = vedtaksbrevsoppsummeringRepository.findByBehandlingId(behandlingId) if (vedtaksbrevsoppsummering != null) { vedtaksbrevsoppsummeringRepository.update(vedtaksbrevsoppsummering.copy(skalSammenslåPerioder = SkalSammenslåPerioder.NEI)) diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/TotrinnController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/TotrinnController.kt index 96f06fd24..0e5e99984 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/TotrinnController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/TotrinnController.kt @@ -5,8 +5,7 @@ import no.nav.familie.kontrakter.felles.Ressurs import no.nav.familie.tilbake.api.dto.TotrinnsvurderingDto import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.familie.tilbake.totrinn.TotrinnService import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType @@ -23,19 +22,22 @@ import java.util.UUID @Validated class TotrinnController( private val totrinnService: TotrinnService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Hent totrinnsvurderinger") @GetMapping( path = ["/{behandlingId}/totrinn/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter totrinnsvurderinger for en gitt behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentTotrinnsvurderinger( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(totrinnService.hentTotrinnsvurderinger(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter totrinnsvurderinger for en gitt behandling", + ) + return Ressurs.success(totrinnService.hentTotrinnsvurderinger(behandlingId)) + } } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/VergeController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/VergeController.kt index ea882d8a1..a44f49cd9 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/VergeController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/VergeController.kt @@ -6,8 +6,7 @@ import no.nav.familie.tilbake.api.dto.VergeDto import no.nav.familie.tilbake.behandling.VergeService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -25,46 +24,49 @@ import java.util.UUID @Validated class VergeController( private val vergeService: VergeService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Opprett verge steg på behandling") @PostMapping - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Oppretter verge steg på behandling", - AuditLoggerEvent.CREATE, - HenteParam.BEHANDLING_ID, - ) fun opprettVergeSteg( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.CREATE, + handling = "Oppretter verge steg på behandling", + ) vergeService.opprettVergeSteg(behandlingId) return Ressurs.success("OK") } @Operation(summary = "Fjern verge") @PutMapping - @Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Deaktiverer ev. eksisterende verge.", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun fjernVerge( @PathVariable("behandlingId") behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Deaktiverer ev. eksisterende verge.", + ) vergeService.fjernVerge(behandlingId) return Ressurs.success("OK") } @Operation(summary = "Hent verge") @GetMapping - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter verge informasjon", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentVerge( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(vergeService.hentVerge(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId, + Behandlerrolle.VEILEDER, + AuditLoggerEvent.ACCESS, + "Henter verge informasjon", + ) + return Ressurs.success(vergeService.hentVerge(behandlingId)) + } } diff --git "a/src/main/kotlin/no/nav/familie/tilbake/api/Vilk\303\245rsvurderingController.kt" "b/src/main/kotlin/no/nav/familie/tilbake/api/Vilk\303\245rsvurderingController.kt" index d234f62f0..013b90233 100644 --- "a/src/main/kotlin/no/nav/familie/tilbake/api/Vilk\303\245rsvurderingController.kt" +++ "b/src/main/kotlin/no/nav/familie/tilbake/api/Vilk\303\245rsvurderingController.kt" @@ -5,8 +5,7 @@ import no.nav.familie.kontrakter.felles.Ressurs import no.nav.familie.tilbake.api.dto.VurdertVilkårsvurderingDto import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.familie.tilbake.vilkårsvurdering.VilkårsvurderingService import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType @@ -23,34 +22,39 @@ import java.util.UUID @Validated class VilkårsvurderingController( val vilkårsvurderingService: VilkårsvurderingService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Hent vilkårsvurdering") @GetMapping( path = ["{behandlingId}/vilkarsvurdering/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter vilkårsvurdering for en gitt behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentVurdertVilkårsvurdering( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs = Ressurs.success(vilkårsvurderingService.hentVilkårsvurdering(behandlingId)) + ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter vilkårsvurdering for en gitt behandling", + ) + return Ressurs.success(vilkårsvurderingService.hentVilkårsvurdering(behandlingId)) + } @Operation(summary = "Hent inaktive vilkårsvurderinger") @GetMapping( path = ["{behandlingId}/vilkarsvurdering/inaktiv"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "Henter inaktive vilkårsvurderinger for en gitt behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) fun hentInaktivVilkårsvurdering( @PathVariable("behandlingId") behandlingId: UUID, - ): Ressurs> = Ressurs.success(vilkårsvurderingService.hentInaktivVilkårsvurdering(behandlingId)) + ): Ressurs> { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.VEILEDER, + auditLoggerEvent = AuditLoggerEvent.ACCESS, + handling = "Henter inaktive vilkårsvurderinger for en gitt behandling", + ) + return Ressurs.success(vilkårsvurderingService.hentInaktivVilkårsvurdering(behandlingId)) + } } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/e2e/AutotestController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/e2e/AutotestController.kt index 000364d02..a651f3c69 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/e2e/AutotestController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/e2e/AutotestController.kt @@ -21,8 +21,7 @@ import no.nav.familie.tilbake.kravgrunnlag.task.BehandleStatusmeldingTask import no.nav.familie.tilbake.log.SecureLog import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.context.annotation.Profile import org.springframework.core.env.Environment @@ -48,6 +47,7 @@ class AutotestController( private val requestSendtRepository: HentFagsystemsbehandlingRequestSendtRepository, private val kafkaProducer: KafkaProducer, private val environment: Environment, + private val tilgangAdvice: TilgangAdvice, ) { @PostMapping(path = ["/opprett/kravgrunnlag/"]) fun opprettKravgrunnlag( @@ -89,16 +89,16 @@ class AutotestController( path = ["/behandling/{behandlingId}/endre/saksbehandler/{nyAnsvarligSaksbehandler}"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, - handling = "endre ansvarlig saksbehandler", - AuditLoggerEvent.UPDATE, - henteParam = HenteParam.BEHANDLING_ID, - ) fun endreAnsvarligSaksbehandler( @PathVariable behandlingId: UUID, @PathVariable nyAnsvarligSaksbehandler: String, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.SAKSBEHANDLER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "endre ansvarlig saksbehandler", + ) val behandling = behandlingRepository.findByIdOrThrow(behandlingId) behandlingRepository.update(behandling.copy(ansvarligSaksbehandler = nyAnsvarligSaksbehandler)) return Ressurs.success("OK") diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningController.kt index 6fd35aae5..169ffdfcd 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningController.kt @@ -14,6 +14,7 @@ import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle import no.nav.familie.tilbake.sikkerhet.HenteParam import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.http.MediaType import org.springframework.validation.annotation.Validated @@ -41,22 +42,23 @@ class ForvaltningController( private val oppgaveTaskService: OppgaveTaskService, private val behandlingTilstandService: BehandlingTilstandService, private val logService: LogService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation(summary = "Hent korrigert kravgrunnlag") @PutMapping( path = ["/behandling/{behandlingId}/kravgrunnlag/{eksternKravgrunnlagId}/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Henter korrigert kravgrunnlag fra økonomi og oppdaterer kravgrunnlag431", - AuditLoggerEvent.NONE, - HenteParam.BEHANDLING_ID, - ) fun korrigerKravgrunnlag( @PathVariable behandlingId: UUID, @PathVariable eksternKravgrunnlagId: BigInteger, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.FORVALTER, + auditLoggerEvent = AuditLoggerEvent.NONE, + handling = "Henter korrigert kravgrunnlag fra økonomi og oppdaterer kravgrunnlag431", + ) forvaltningService.korrigerKravgrunnlag(behandlingId, eksternKravgrunnlagId) return Ressurs.success("OK") } @@ -66,15 +68,15 @@ class ForvaltningController( path = ["/behandling/{behandlingId}/kravgrunnlag/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Henter korrigert kravgrunnlag fra økonomi og oppdaterer kravgrunnlag431", - AuditLoggerEvent.NONE, - HenteParam.BEHANDLING_ID, - ) fun korrigerKravgrunnlag( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.FORVALTER, + auditLoggerEvent = AuditLoggerEvent.NONE, + handling = "Henter korrigert kravgrunnlag fra økonomi og oppdaterer kravgrunnlag431", + ) forvaltningService.korrigerKravgrunnlag(behandlingId) return Ressurs.success("OK") } @@ -102,15 +104,15 @@ class ForvaltningController( path = ["/behandling/{behandlingId}/tving-henleggelse/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Tving henlegger behandling", - AuditLoggerEvent.NONE, - HenteParam.BEHANDLING_ID, - ) fun tvingHenleggBehandling( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.FORVALTER, + auditLoggerEvent = AuditLoggerEvent.NONE, + handling = "Tving henlegger behandling", + ) forvaltningService.tvingHenleggBehandling(behandlingId) return Ressurs.success("OK") } @@ -120,15 +122,15 @@ class ForvaltningController( path = ["/behandling/{behandlingId}/flytt-behandling/v1"], produces = [MediaType.APPLICATION_JSON_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Flytter behandling tilbake til Fakta", - AuditLoggerEvent.UPDATE, - HenteParam.BEHANDLING_ID, - ) fun flyttBehandlingTilFakta( @PathVariable behandlingId: UUID, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.FORVALTER, + auditLoggerEvent = AuditLoggerEvent.UPDATE, + handling = "Flytter behandling tilbake til Fakta", + ) forvaltningService.flyttBehandlingsstegTilbakeTilFakta(behandlingId) return Ressurs.success("OK") } diff --git a/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningPreprodController.kt b/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningPreprodController.kt index 318ea57f9..805acd94a 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningPreprodController.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/api/forvaltning/ForvaltningPreprodController.kt @@ -5,8 +5,7 @@ import no.nav.familie.kontrakter.felles.Ressurs import no.nav.familie.tilbake.forvaltning.ForvaltningPreprodService import no.nav.familie.tilbake.sikkerhet.AuditLoggerEvent import no.nav.familie.tilbake.sikkerhet.Behandlerrolle -import no.nav.familie.tilbake.sikkerhet.HenteParam -import no.nav.familie.tilbake.sikkerhet.Rolletilgangssjekk +import no.nav.familie.tilbake.sikkerhet.TilgangAdvice import no.nav.security.token.support.core.api.ProtectedWithClaims import org.springframework.context.annotation.Profile import org.springframework.core.env.Environment @@ -29,6 +28,7 @@ import java.util.UUID class ForvaltningPreprodController( private val environment: Environment, private val forvaltningPreprodService: ForvaltningPreprodService, + private val tilgangAdvice: TilgangAdvice, ) { @Operation( description = @@ -49,16 +49,16 @@ class ForvaltningPreprodController( produces = [MediaType.APPLICATION_JSON_VALUE], consumes = [MediaType.TEXT_XML_VALUE], ) - @Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Legg inn testkravgrunnlag - preprod", - AuditLoggerEvent.NONE, - HenteParam.BEHANDLING_ID, - ) fun simulerMottakAvKravgrunnlag( @PathVariable behandlingId: UUID, @RequestBody kravgrunnlag: String, ): Ressurs { + tilgangAdvice.validerTilgangBehandlingID( + behandlingId = behandlingId, + minimumBehandlerrolle = Behandlerrolle.FORVALTER, + auditLoggerEvent = AuditLoggerEvent.NONE, + handling = "Legg inn testkravgrunnlag - preprod", + ) if (environment.activeProfiles.contains("prod")) { throw IllegalStateException("Kan ikke kjøre denne tjenesten i prod") } diff --git a/src/main/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdvice.kt b/src/main/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdvice.kt index 23b92a362..d3e4b44a1 100644 --- a/src/main/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdvice.kt +++ b/src/main/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdvice.kt @@ -3,7 +3,6 @@ package no.nav.familie.tilbake.sikkerhet import no.nav.familie.kontrakter.felles.Fagsystem import no.nav.familie.kontrakter.felles.Tema import no.nav.familie.kontrakter.felles.tilbakekreving.Ytelsestype -import no.nav.familie.tilbake.api.dto.BehandlingsstegFatteVedtaksstegDto import no.nav.familie.tilbake.behandling.BehandlingRepository import no.nav.familie.tilbake.behandling.FagsakRepository import no.nav.familie.tilbake.behandling.FagsystemUtil @@ -34,7 +33,6 @@ import kotlin.reflect.KProperty1 import kotlin.reflect.full.declaredMemberProperties enum class HenteParam { - BEHANDLING_ID, YTELSESTYPE_OG_EKSTERN_FAGSAK_ID, FAGSYSTEM_OG_EKSTERN_FAGSAK_ID, MOTTATT_XML_ID, @@ -66,11 +64,7 @@ class TilgangAdvice( joinpoint: JoinPoint, rolletilgangssjekk: Rolletilgangssjekk, ) { - if (ContextService.hentSaksbehandler(SecureLog.Context.tom()) == Constants.BRUKER_ID_VEDTAKSLØSNINGEN) { - // når behandler har system tilgang, trenges ikke det validering på fagsystem eller rolle - return - } - + val saksbehandler = ContextService.hentSaksbehandler(SecureLog.Context.tom()) val httpRequest = (RequestContextHolder.currentRequestAttributes() as ServletRequestAttributes).request if (HttpMethod.GET.matches(httpRequest.method) || rolletilgangssjekk.henteParam != HenteParam.INGEN) { @@ -78,72 +72,85 @@ class TilgangAdvice( rolletilgangssjekk.henteParam, joinpoint.args, rolletilgangssjekk, + saksbehandler, ) } else if (HttpMethod.POST.matches(httpRequest.method) || HttpMethod.PUT.matches(httpRequest.method)) { validateFagsystemTilgangIPostRequest( joinpoint.args[0], rolletilgangssjekk, + saksbehandler, ) } else { logger.error("${httpRequest.requestURI} støtter ikke tilgangssjekk") } } + fun validerTilgangBehandlingID( + behandlingId: UUID, + minimumBehandlerrolle: Behandlerrolle, + auditLoggerEvent: AuditLoggerEvent, + handling: String, + ) { + val saksbehandler = ContextService.hentSaksbehandler(SecureLog.Context.tom()) + if (saksbehandler == Constants.BRUKER_ID_VEDTAKSLØSNINGEN) { + // når behandler har system tilgang, trenges ikke det validering på fagsystem eller rolle + return + } + val behandling = behandlingRepository.findByIdOrThrow(behandlingId) + val fagsak = fagsakRepository.findByIdOrThrow(behandling.fagsakId) + val logContext = SecureLog.Context.medBehandling(fagsak.eksternFagsakId, behandling.id.toString()) + + validate( + fagsystem = fagsak.fagsystem, + minimumBehandlerrolle = minimumBehandlerrolle, + fagsak = fagsak, + handling = handling, + logContext = logContext, + saksbehandler = saksbehandler, + ) + logAccess(auditLoggerEvent, fagsak, behandling) + } + private fun validateFagsystemTilgangIGetRequest( param: HenteParam, requestBody: Array, rolletilgangssjekk: Rolletilgangssjekk, + saksbehandler: String, ) { when (param) { - HenteParam.BEHANDLING_ID -> { - val behandlingId = requestBody.first() as UUID - val behandling = behandlingRepository.findByIdOrThrow(behandlingId) - val fagsak = fagsakRepository.findByIdOrThrow(behandling.fagsakId) - - var behandlerRolle = rolletilgangssjekk.minimumBehandlerrolle - if (requestBody.size > 1) { - behandlerRolle = - bestemBehandlerRolleForUtførFatteVedtakSteg( - requestBody[1], - rolletilgangssjekk.minimumBehandlerrolle, - ) - } - validate( - fagsystem = fagsak.fagsystem, - minimumBehandlerrolle = behandlerRolle, - fagsak = fagsak, - handling = rolletilgangssjekk.handling, - ) - logAccess(rolletilgangssjekk, fagsak, behandling) - } - HenteParam.YTELSESTYPE_OG_EKSTERN_FAGSAK_ID -> { val ytelsestype = Ytelsestype.valueOf(requestBody.first().toString()) val fagsystem = FagsystemUtil.hentFagsystemFraYtelsestype(ytelsestype) val eksternFagsakId = requestBody[1].toString() val fagsak = fagsakRepository.findByFagsystemAndEksternFagsakId(fagsystem, eksternFagsakId) + val logContext = SecureLog.Context.utenBehandling(fagsak?.eksternFagsakId) validate( fagsystem = fagsystem, minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = fagsak, handling = rolletilgangssjekk.handling, + logContext = logContext, + saksbehandler = saksbehandler, ) - logAccess(rolletilgangssjekk, fagsak) + logAccess(rolletilgangssjekk.auditLoggerEvent, fagsak) } HenteParam.FAGSYSTEM_OG_EKSTERN_FAGSAK_ID -> { val fagsystem = Fagsystem.valueOf(requestBody.first().toString()) val eksternFagsakId = requestBody[1].toString() val fagsak = fagsakRepository.findByFagsystemAndEksternFagsakId(fagsystem, eksternFagsakId) + val logContext = SecureLog.Context.utenBehandling(fagsak?.eksternFagsakId) validate( fagsystem = fagsystem, minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = fagsak, handling = rolletilgangssjekk.handling, + logContext = logContext, + saksbehandler = saksbehandler, ) - logAccess(rolletilgangssjekk, fagsak) + logAccess(rolletilgangssjekk.auditLoggerEvent, fagsak) } HenteParam.MOTTATT_XML_ID -> { @@ -155,6 +162,8 @@ class TilgangAdvice( minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = null, handling = rolletilgangssjekk.handling, + logContext = SecureLog.Context.tom(), + saksbehandler = saksbehandler, ) } @@ -176,6 +185,8 @@ class TilgangAdvice( minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = null, handling = rolletilgangssjekk.handling, + logContext = SecureLog.Context.tom(), + saksbehandler = saksbehandler, ) } @@ -188,6 +199,7 @@ class TilgangAdvice( private fun validateFagsystemTilgangIPostRequest( requestBody: Any, rolletilgangssjekk: Rolletilgangssjekk, + saksbehandler: String, ) { val fields: Collection> = requestBody::class.declaredMemberProperties @@ -202,41 +214,50 @@ class TilgangAdvice( val behandlingId: UUID = behandlingIdFraRequest.getter.call(requestBody) as UUID val behandling = behandlingRepository.findByIdOrThrow(behandlingId) val fagsak = fagsakRepository.findByIdOrThrow(behandling.fagsakId) + val logContext = SecureLog.Context.medBehandling(fagsak.eksternFagsakId, behandling.id.toString()) validate( fagsystem = fagsak.fagsystem, minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = fagsak, handling = rolletilgangssjekk.handling, + logContext = logContext, + saksbehandler = saksbehandler, ) - logAccess(rolletilgangssjekk, fagsak, behandling) + logAccess(rolletilgangssjekk.auditLoggerEvent, fagsak, behandling) } eksternBrukIdFraRequest != null -> { val eksternBrukId: UUID = eksternBrukIdFraRequest.getter.call(requestBody) as UUID val fagsak = fagsakRepository.finnFagsakForEksternBrukId(eksternBrukId) + val logContext = SecureLog.Context.utenBehandling(fagsak.eksternFagsakId) validate( fagsystem = fagsak.fagsystem, minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = fagsak, handling = rolletilgangssjekk.handling, + logContext = logContext, + saksbehandler = saksbehandler, ) - logAccess(rolletilgangssjekk, fagsak) + logAccess(rolletilgangssjekk.auditLoggerEvent, fagsak) } fagsystemFraRequest != null && eksternFagsakIdFraRequest != null -> { val fagsystem = fagsystemFraRequest.getter.call(requestBody) as Fagsystem val eksternFagsakId = eksternFagsakIdFraRequest.getter.call(requestBody).toString() val fagsak = fagsakRepository.findByFagsystemAndEksternFagsakId(fagsystem, eksternFagsakId) + val logContext = SecureLog.Context.utenBehandling(eksternFagsakId) validate( fagsystem = fagsystem, minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = fagsak, handling = rolletilgangssjekk.handling, + logContext = logContext, + saksbehandler = saksbehandler, ) - logAccess(rolletilgangssjekk, fagsak) + logAccess(rolletilgangssjekk.auditLoggerEvent, fagsak) } ytelsestypeFraRequest != null && eksternFagsakIdFraRequest != null -> { @@ -244,14 +265,17 @@ class TilgangAdvice( val fagsystem = FagsystemUtil.hentFagsystemFraYtelsestype(ytelsestype) val eksternFagsakId = eksternFagsakIdFraRequest.getter.call(requestBody).toString() val fagsak = fagsakRepository.findByFagsystemAndEksternFagsakId(fagsystem, eksternFagsakId) + val logContext = SecureLog.Context.utenBehandling(eksternFagsakId) validate( fagsystem = fagsystem, minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = fagsak, handling = rolletilgangssjekk.handling, + logContext = logContext, + saksbehandler = saksbehandler, ) - logAccess(rolletilgangssjekk, fagsak) + logAccess(rolletilgangssjekk.auditLoggerEvent, fagsak) } ytelsestypeFraRequest != null -> { @@ -262,6 +286,8 @@ class TilgangAdvice( minimumBehandlerrolle = rolletilgangssjekk.minimumBehandlerrolle, fagsak = null, handling = rolletilgangssjekk.handling, + logContext = SecureLog.Context.tom(), + saksbehandler = saksbehandler, ) } @@ -276,6 +302,8 @@ class TilgangAdvice( minimumBehandlerrolle: Behandlerrolle, fagsak: Fagsak?, handling: String, + logContext: SecureLog.Context, + saksbehandler: String, ) { val brukerRolleOgFagsystemstilgang = ContextService.hentHøyesteRolletilgangOgYtelsestypeForInnloggetBruker(rolleConfig, handling, SecureLog.Context.tom()) @@ -286,35 +314,39 @@ class TilgangAdvice( brukerRolleOgFagsystemstilgang = brukerRolleOgFagsystemstilgang, minimumBehandlerrolle = minimumBehandlerrolle, handling = handling, + saksbehandler = saksbehandler, ) return } val tilgangskontrollsfagsystem = Tilgangskontrollsfagsystem.fraFagsystem(fagsystem) // sjekk om saksbehandler har riktig gruppe å aksessere denne ytelsestypen - validateFagsystem(tilgangskontrollsfagsystem, brukerRolleOgFagsystemstilgang, handling) + validateFagsystem(tilgangskontrollsfagsystem, brukerRolleOgFagsystemstilgang, handling, saksbehandler) // sjekk om saksbehandler har riktig rolle å aksessere denne ytelsestypen validateRolle( brukersrolleTilFagsystemet = brukerRolleOgFagsystemstilgang.tilganger.getValue(tilgangskontrollsfagsystem), minimumBehandlerrolle = minimumBehandlerrolle, handling = handling, + logContext = logContext, + saksbehandler = saksbehandler, ) validateEgenAnsattKode6Kode7( fagsak = fagsak, handling = handling, + saksbehandler = saksbehandler, ) } fun logAccess( - rolletilgangssjekk: Rolletilgangssjekk, + auditLoggerEvent: AuditLoggerEvent, fagsak: Fagsak?, behandling: Behandling? = null, ) { fagsak?.let { auditLogger.log( Sporingsdata( - rolletilgangssjekk.auditLoggerEvent, + auditLoggerEvent, fagsak.bruker.ident, CustomKeyValue("eksternFagsakId", fagsak.eksternFagsakId), behandling?.let { @@ -328,6 +360,7 @@ class TilgangAdvice( private fun validateEgenAnsattKode6Kode7( fagsak: Fagsak?, handling: String, + saksbehandler: String, ) { val personerIBehandlingen = fagsak?.bruker?.ident?.let { listOf(it) } ?: return val fagsakSystem = fagsak.fagsystem @@ -335,8 +368,8 @@ class TilgangAdvice( val tilganger = integrasjonerClient.sjekkTilgangTilPersoner(personerIBehandlingen, fagsakSystem.tilTema()) if (tilganger.any { !it.harTilgang }) { throw Feil( - message = "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} har ikke tilgang til person i $handling", - frontendFeilmelding = "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} har ikke tilgang til person i $handling", + message = "$saksbehandler har ikke tilgang til person i $handling", + frontendFeilmelding = "$saksbehandler har ikke tilgang til person i $handling", logContext = SecureLog.Context.tom(), httpStatus = HttpStatus.FORBIDDEN, ) @@ -358,11 +391,12 @@ class TilgangAdvice( fagsystem: Tilgangskontrollsfagsystem, brukerRolleOgFagsystemstilgang: InnloggetBrukertilgang, handling: String, + saksbehandler: String, ) { if (!brukerRolleOgFagsystemstilgang.tilganger.contains(fagsystem)) { throw Feil( - message = "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} har ikke tilgang til $handling", - frontendFeilmelding = "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} har ikke tilgang til $handling", + message = "$saksbehandler har ikke tilgang til $handling", + frontendFeilmelding = "$saksbehandler har ikke tilgang til $handling", logContext = SecureLog.Context.tom(), httpStatus = HttpStatus.FORBIDDEN, ) @@ -373,24 +407,26 @@ class TilgangAdvice( brukersrolleTilFagsystemet: Behandlerrolle, minimumBehandlerrolle: Behandlerrolle, handling: String, + logContext: SecureLog.Context, + saksbehandler: String, ) { if (minimumBehandlerrolle == Behandlerrolle.FORVALTER) { throw Feil( message = - "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} med rolle $brukersrolleTilFagsystemet " + + "$saksbehandler med rolle $brukersrolleTilFagsystemet " + "har ikke tilgang til å kalle forvaltningstjeneste $handling. Krever FORVALTER.", frontendFeilmelding = "Du har ikke tilgang til å $handling.", - logContext = SecureLog.Context.tom(), + logContext = logContext, httpStatus = HttpStatus.FORBIDDEN, ) } if (minimumBehandlerrolle.nivå > brukersrolleTilFagsystemet.nivå) { throw Feil( message = - "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} med rolle $brukersrolleTilFagsystemet " + + "$saksbehandler med rolle $brukersrolleTilFagsystemet " + "har ikke tilgang til å $handling. Krever $minimumBehandlerrolle.", frontendFeilmelding = "Du har ikke tilgang til å $handling.", - logContext = SecureLog.Context.tom(), + logContext = logContext, httpStatus = HttpStatus.FORBIDDEN, ) } @@ -400,6 +436,7 @@ class TilgangAdvice( brukerRolleOgFagsystemstilgang: InnloggetBrukertilgang, minimumBehandlerrolle: Behandlerrolle, handling: String, + saksbehandler: String, ) { val tilganger = brukerRolleOgFagsystemstilgang.tilganger // Forvalter kan kun kalle forvaltningstjenestene og tjenestene som kan kalles av Veileder @@ -408,7 +445,7 @@ class TilgangAdvice( ) { throw Feil( message = - "${ContextService.hentSaksbehandler(SecureLog.Context.tom())} med rolle FORVALTER " + + "$saksbehandler med rolle FORVALTER " + "har ikke tilgang til å $handling. Krever $minimumBehandlerrolle.", frontendFeilmelding = "Du har ikke tilgang til å $handling.", logContext = SecureLog.Context.tom(), @@ -428,15 +465,4 @@ class TilgangAdvice( httpStatus = HttpStatus.BAD_REQUEST, ) } - - private fun bestemBehandlerRolleForUtførFatteVedtakSteg( - requestBody: Any, - minimumBehandlerrolle: Behandlerrolle, - ): Behandlerrolle { - // Behandlerrolle blir endret til Beslutter kun når FatteVedtak steg utføres - if (requestBody is BehandlingsstegFatteVedtaksstegDto) { - return Behandlerrolle.BESLUTTER - } - return minimumBehandlerrolle - } } diff --git a/src/test/kotlin/no/nav/familie/tilbake/api/BehandlingControllerTest.kt b/src/test/kotlin/no/nav/familie/tilbake/api/BehandlingControllerTest.kt index c4f3a3d90..af431bf0f 100644 --- a/src/test/kotlin/no/nav/familie/tilbake/api/BehandlingControllerTest.kt +++ b/src/test/kotlin/no/nav/familie/tilbake/api/BehandlingControllerTest.kt @@ -1,11 +1,14 @@ package no.nav.familie.tilbake.api +import io.kotest.matchers.shouldBe import io.mockk.every import io.mockk.mockkObject import io.mockk.unmockkObject import no.nav.familie.kontrakter.felles.Fagsystem +import no.nav.familie.kontrakter.felles.Ressurs import no.nav.familie.kontrakter.felles.tilbakekreving.Ytelsestype import no.nav.familie.tilbake.OppslagSpringRunnerTest +import no.nav.familie.tilbake.api.dto.BehandlingsstegFatteVedtaksstegDtoTest import no.nav.familie.tilbake.behandling.BehandlingRepository import no.nav.familie.tilbake.behandling.FagsakRepository import no.nav.familie.tilbake.behandling.domain.Behandlingsstatus @@ -126,6 +129,38 @@ class BehandlingControllerTest : OppslagSpringRunnerTest() { assertThat(response.body).contains("Behandling er på vent og kan derfor ikke flyttes tilbake til fakta") } + @Test + fun `Saksbehandler uten beslutterrolle kan ikke godkjenne vedtak`() { + every { ContextService.hentHøyesteRolletilgangOgYtelsestypeForInnloggetBruker(any(), any(), any()) } + .returns(InnloggetBrukertilgang(mapOf(Tilgangskontrollsfagsystem.ENSLIG_FORELDER to Behandlerrolle.SAKSBEHANDLER))) + + val behandlingId = opprettTestdata(behandlingStatus = Behandlingsstatus.FATTER_VEDTAK) + val response = + restTemplate.exchange>( + localhost("/api/behandling/$behandlingId/steg/v1"), + HttpMethod.POST, + HttpEntity(BehandlingsstegFatteVedtaksstegDtoTest.ny(), headers), + ) + response.statusCode shouldBe HttpStatus.FORBIDDEN + response.body?.melding shouldBe "saksbehandler med rolle SAKSBEHANDLER har ikke tilgang til å Utfører behandlingens aktiv steg og fortsetter den til neste steg. Krever BESLUTTER." + } + + @Test + fun `Saksbehandler med beslutterrolle kan godkjenne vedtak`() { + every { ContextService.hentHøyesteRolletilgangOgYtelsestypeForInnloggetBruker(any(), any(), any()) } + .returns(InnloggetBrukertilgang(mapOf(Tilgangskontrollsfagsystem.ENSLIG_FORELDER to Behandlerrolle.BESLUTTER))) + + val behandlingId = opprettTestdata(behandlingStatus = Behandlingsstatus.FATTER_VEDTAK) + val response = + restTemplate.exchange>( + localhost("/api/behandling/$behandlingId/steg/v1"), + HttpMethod.POST, + HttpEntity(BehandlingsstegFatteVedtaksstegDtoTest.ny(), headers), + ) + response.statusCode shouldBe HttpStatus.BAD_REQUEST + response.body?.melding shouldBe "ansvarlig beslutter kan ikke være samme som ansvarlig saksbehandler" + } + private fun flyttBehandlingTilFakta( behandlingId: UUID, ): ResponseEntity = diff --git a/src/test/kotlin/no/nav/familie/tilbake/api/dto/BehandlingsstegFatteVedtaksstegDtoTest.kt b/src/test/kotlin/no/nav/familie/tilbake/api/dto/BehandlingsstegFatteVedtaksstegDtoTest.kt new file mode 100644 index 000000000..e5471d3bb --- /dev/null +++ b/src/test/kotlin/no/nav/familie/tilbake/api/dto/BehandlingsstegFatteVedtaksstegDtoTest.kt @@ -0,0 +1,33 @@ +package no.nav.familie.tilbake.api.dto + +import no.nav.familie.tilbake.behandlingskontroll.domain.Behandlingssteg + +class BehandlingsstegFatteVedtaksstegDtoTest { + companion object { + fun ny(godkjent: Boolean = true): BehandlingsstegFatteVedtaksstegDto = + BehandlingsstegFatteVedtaksstegDto( + listOf( + VurdertTotrinnDto( + behandlingssteg = Behandlingssteg.FAKTA, + godkjent = godkjent, + begrunnelse = "fakta totrinn begrunnelse", + ), + VurdertTotrinnDto( + behandlingssteg = Behandlingssteg.FORELDELSE, + godkjent = godkjent, + begrunnelse = "foreldelse totrinn begrunnelse", + ), + VurdertTotrinnDto( + behandlingssteg = Behandlingssteg.VILKÅRSVURDERING, + godkjent = godkjent, + begrunnelse = "vilkårsvurdering totrinn begrunnelse", + ), + VurdertTotrinnDto( + behandlingssteg = Behandlingssteg.FORESLÅ_VEDTAK, + godkjent = godkjent, + begrunnelse = "foreslåvedtak totrinn begrunnelse", + ), + ), + ) + } +} diff --git a/src/test/kotlin/no/nav/familie/tilbake/behandling/steg/StegServiceTest.kt b/src/test/kotlin/no/nav/familie/tilbake/behandling/steg/StegServiceTest.kt index caa242b8f..0c7d46f7b 100644 --- a/src/test/kotlin/no/nav/familie/tilbake/behandling/steg/StegServiceTest.kt +++ b/src/test/kotlin/no/nav/familie/tilbake/behandling/steg/StegServiceTest.kt @@ -21,7 +21,7 @@ import no.nav.familie.prosessering.domene.Status import no.nav.familie.prosessering.internal.TaskService import no.nav.familie.tilbake.OppslagSpringRunnerTest import no.nav.familie.tilbake.api.dto.BehandlingsstegFaktaDto -import no.nav.familie.tilbake.api.dto.BehandlingsstegFatteVedtaksstegDto +import no.nav.familie.tilbake.api.dto.BehandlingsstegFatteVedtaksstegDtoTest import no.nav.familie.tilbake.api.dto.BehandlingsstegForeldelseDto import no.nav.familie.tilbake.api.dto.BehandlingsstegForeslåVedtaksstegDto import no.nav.familie.tilbake.api.dto.BehandlingsstegVergeDto @@ -33,7 +33,6 @@ import no.nav.familie.tilbake.api.dto.GodTroDto import no.nav.familie.tilbake.api.dto.PeriodeMedTekstDto import no.nav.familie.tilbake.api.dto.VergeDto import no.nav.familie.tilbake.api.dto.VilkårsvurderingsperiodeDto -import no.nav.familie.tilbake.api.dto.VurdertTotrinnDto import no.nav.familie.tilbake.behandling.BehandlingRepository import no.nav.familie.tilbake.behandling.FagsakRepository import no.nav.familie.tilbake.behandling.VergeService @@ -610,7 +609,7 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { assertOppgave(FerdigstillOppgaveTask.TYPE) assertOppgave(LagOppgaveTask.TYPE) - stegService.håndterSteg(behandlingId, lagBehandlingsstegFatteVedtaksstegDto(godkjent = false), SecureLog.Context.tom()) + stegService.håndterSteg(behandlingId, BehandlingsstegFatteVedtaksstegDtoTest.ny(godkjent = false), SecureLog.Context.tom()) assertOppgave(FerdigstillOppgaveTask.TYPE, 2) assertOppgave(LagOppgaveTask.TYPE, 2) @@ -644,7 +643,7 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { lagBehandlingsstegstilstand(Behandlingssteg.FORESLÅ_VEDTAK, Behandlingsstegstatus.UTFØRT) lagBehandlingsstegstilstand(Behandlingssteg.FATTE_VEDTAK, Behandlingsstegstatus.KLAR) - stegService.håndterSteg(behandlingId, lagBehandlingsstegFatteVedtaksstegDto(godkjent = true), SecureLog.Context.tom()) + stegService.håndterSteg(behandlingId, BehandlingsstegFatteVedtaksstegDtoTest.ny(godkjent = true), SecureLog.Context.tom()) val behandlingsstegstilstander = behandlingsstegstilstandRepository.findByBehandlingId(behandlingId) assertBehandlingssteg(behandlingsstegstilstander, Behandlingssteg.IVERKSETT_VEDTAK, Behandlingsstegstatus.KLAR) @@ -685,7 +684,7 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { lagBehandlingsstegstilstand(Behandlingssteg.FORESLÅ_VEDTAK, Behandlingsstegstatus.UTFØRT) lagBehandlingsstegstilstand(Behandlingssteg.FATTE_VEDTAK, Behandlingsstegstatus.KLAR) - stegService.håndterSteg(behandlingId, lagBehandlingsstegFatteVedtaksstegDto(godkjent = false), SecureLog.Context.tom()) + stegService.håndterSteg(behandlingId, BehandlingsstegFatteVedtaksstegDtoTest.ny(godkjent = false), SecureLog.Context.tom()) val behandlingsstegstilstander = behandlingsstegstilstandRepository.findByBehandlingId(behandlingId) assertBehandlingssteg(behandlingsstegstilstander, Behandlingssteg.FORESLÅ_VEDTAK, Behandlingsstegstatus.KLAR) @@ -746,7 +745,7 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { val exception = shouldThrow { - stegService.håndterSteg(behandlingId, lagBehandlingsstegFatteVedtaksstegDto(godkjent = true), SecureLog.Context.tom()) + stegService.håndterSteg(behandlingId, BehandlingsstegFatteVedtaksstegDtoTest.ny(godkjent = true), SecureLog.Context.tom()) } exception.message shouldBe "ansvarlig beslutter kan ikke være samme som ansvarlig saksbehandler" @@ -933,7 +932,7 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { lagBehandlingsstegstilstand(Behandlingssteg.FORESLÅ_VEDTAK, Behandlingsstegstatus.UTFØRT) lagBehandlingsstegstilstand(Behandlingssteg.FATTE_VEDTAK, Behandlingsstegstatus.KLAR) - val behandlingsstegDto = lagBehandlingsstegFatteVedtaksstegDto(godkjent = false) + val behandlingsstegDto = BehandlingsstegFatteVedtaksstegDtoTest.ny(godkjent = false) stegService .kanAnsvarligSaksbehandlerOppdateres(behandlingId, behandlingsstegDto) .shouldBeFalse() @@ -947,7 +946,7 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { lagBehandlingsstegstilstand(Behandlingssteg.FORESLÅ_VEDTAK, Behandlingsstegstatus.UTFØRT) lagBehandlingsstegstilstand(Behandlingssteg.FATTE_VEDTAK, Behandlingsstegstatus.KLAR) - val behandlingsstegDto = lagBehandlingsstegFatteVedtaksstegDto(godkjent = true) + val behandlingsstegDto = BehandlingsstegFatteVedtaksstegDtoTest.ny(godkjent = true) stegService .kanAnsvarligSaksbehandlerOppdateres(behandlingId, behandlingsstegDto) .shouldBeFalse() @@ -1020,32 +1019,6 @@ internal class StegServiceTest : OppslagSpringRunnerTest() { ), ) - private fun lagBehandlingsstegFatteVedtaksstegDto(godkjent: Boolean): BehandlingsstegFatteVedtaksstegDto = - BehandlingsstegFatteVedtaksstegDto( - listOf( - VurdertTotrinnDto( - behandlingssteg = Behandlingssteg.FAKTA, - godkjent = godkjent, - begrunnelse = "fakta totrinn begrunnelse", - ), - VurdertTotrinnDto( - behandlingssteg = Behandlingssteg.FORELDELSE, - godkjent = godkjent, - begrunnelse = "foreldelse totrinn begrunnelse", - ), - VurdertTotrinnDto( - behandlingssteg = Behandlingssteg.VILKÅRSVURDERING, - godkjent = godkjent, - begrunnelse = "vilkårsvurdering totrinn begrunnelse", - ), - VurdertTotrinnDto( - behandlingssteg = Behandlingssteg.FORESLÅ_VEDTAK, - godkjent = godkjent, - begrunnelse = "foreslåvedtak totrinn begrunnelse", - ), - ), - ) - private fun assertBehandlingssteg( behandlingsstegstilstand: List, behandlingssteg: Behandlingssteg, diff --git a/src/test/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdviceTest.kt b/src/test/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdviceTest.kt index d2dda17bf..34b632972 100644 --- a/src/test/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdviceTest.kt +++ b/src/test/kotlin/no/nav/familie/tilbake/sikkerhet/TilgangAdviceTest.kt @@ -16,9 +16,6 @@ import no.nav.familie.kontrakter.felles.tilbakekreving.Varsel import no.nav.familie.kontrakter.felles.tilbakekreving.Ytelsestype import no.nav.familie.kontrakter.felles.tilgangskontroll.Tilgang import no.nav.familie.tilbake.OppslagSpringRunnerTest -import no.nav.familie.tilbake.api.dto.BehandlingPåVentDto -import no.nav.familie.tilbake.api.dto.BehandlingsstegFaktaDto -import no.nav.familie.tilbake.api.dto.BehandlingsstegFatteVedtaksstegDto import no.nav.familie.tilbake.api.dto.BrukerDto import no.nav.familie.tilbake.api.dto.FagsakDto import no.nav.familie.tilbake.api.dto.HentFagsystemsbehandlingRequestDto @@ -29,7 +26,6 @@ import no.nav.familie.tilbake.behandling.domain.Behandling import no.nav.familie.tilbake.behandling.domain.Behandlingstype import no.nav.familie.tilbake.behandling.domain.Bruker import no.nav.familie.tilbake.behandling.domain.Fagsak -import no.nav.familie.tilbake.behandlingskontroll.domain.Venteårsak import no.nav.familie.tilbake.config.Constants import no.nav.familie.tilbake.config.RolleConfig import no.nav.familie.tilbake.data.Testdata @@ -170,61 +166,44 @@ internal class TilgangAdviceTest : OppslagSpringRunnerTest() { @Test fun `sjekkTilgang skal sperre tilgang hvis person er kode 6`() { - every { mockJoinpoint.args } returns arrayOf(behandling.id) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, false, null)) - val rolletilgangssjekk = - Rolletilgangssjekk(Behandlerrolle.VEILEDER, "hent behandling", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) val token = opprettToken("abc", listOf(BARNETRYGD_BESLUTTER_ROLLE)) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) - shouldThrow { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } - .message shouldBe "abc har ikke tilgang til person i hent behandling" + val exception = shouldThrow { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") } + exception.message shouldBe "abc har ikke tilgang til person i test" } @Test fun `sjekkTilgang skal gi tilgang hvis person ikke er kode 6`() { - every { mockJoinpoint.args } returns arrayOf(behandling.id) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - val rolletilgangssjekk = - Rolletilgangssjekk(Behandlerrolle.VEILEDER, "hent behandling", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) val token = opprettToken("abc", listOf(BARNETRYGD_BESLUTTER_ROLLE)) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal ha tilgang for barnetrygd beslutter i barnetrygd hent behandling request`() { - val token = opprettToken("abc", listOf(BARNETRYGD_BESLUTTER_ROLLE)) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk(Behandlerrolle.VEILEDER, "hent behandling", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) + val token = opprettToken("abc", listOf(BARNETRYGD_BESLUTTER_ROLLE)) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal ikke ha tilgang for enslig beslutter i barnetrygd hent behandling request`() { - val token = opprettToken("abc", listOf(ENSLIG_BESLUTTER_ROLLE)) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.VEILEDER, - "barnetrygd hent behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(ENSLIG_BESLUTTER_ROLLE)) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) val exception = - shouldThrow(block = { - tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) - }) + shouldThrow { + tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") + } - exception.message shouldBe "abc har ikke tilgang til ${rolletilgangssjekk.handling}" + exception.message shouldBe "abc har ikke tilgang til test" } @Test @@ -269,233 +248,111 @@ internal class TilgangAdviceTest : OppslagSpringRunnerTest() { @Test fun `sjekkTilgang skal ha tilgang i hent behandling request når saksbehandler har tilgang til enslig og barnetrygd`() { - val token = opprettToken("abc", listOf(ENSLIG_SAKSBEHANDLER_ROLLE, BARNETRYGD_SAKSBEHANDLER_ROLLE)) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk(Behandlerrolle.VEILEDER, "hent behandling", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) + val token = opprettToken("abc", listOf(ENSLIG_SAKSBEHANDLER_ROLLE, BARNETRYGD_SAKSBEHANDLER_ROLLE)) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal ha tilgang i hent behandling request når bruker er fagsystem`() { - val token = opprettToken(Constants.BRUKER_ID_VEDTAKSLØSNINGEN, listOf()) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk(Behandlerrolle.VEILEDER, "hent behandling", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) + val token = opprettToken(Constants.BRUKER_ID_VEDTAKSLØSNINGEN, listOf()) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal ikke ha tilgang i hent behandling request når bruker er ukjent`() { val token = opprettToken("abc", listOf()) - opprettRequestContext("/api/behandling/v1/$behandling.id", HttpMethod.GET, token) + opprettRequestContext("/api/behandling/v1/${behandling.id}", HttpMethod.GET, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk(Behandlerrolle.VEILEDER, "hent behandling", AuditLoggerEvent.ACCESS, HenteParam.BEHANDLING_ID) val exception = - shouldThrow(block = { - tilgangAdvice.sjekkTilgang( - mockJoinpoint, - rolletilgangssjekk, - ) - }) + shouldThrow { + tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.VEILEDER, AuditLoggerEvent.ACCESS, "test") + } - exception.message shouldBe "Bruker har mangler tilgang til hent behandling" + exception.message shouldBe "Bruker har mangler tilgang til test" } @Test fun `sjekkTilgang skal saksbehandler ha tilgang i Fakta utførBehandlingssteg POST request`() { - val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE)) - // POST request uten body - opprettRequestContext("/api/behandling/$behandling.id/steg/v1/", HttpMethod.POST, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id, BehandlingsstegFaktaDto(emptyList(), "testverdi")) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Håndterer behandlingens aktiv steg og fortsetter den til neste steg", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) - - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } - } - - @Test - fun `sjekkTilgang skal saksbehandler ikke ha tilgang i Fattevedtak utførBehandlingssteg POST request`() { val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE)) - // POST request uten body - opprettRequestContext("/api/behandling/$behandling.id/steg/v1/", HttpMethod.POST, token) - every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id, BehandlingsstegFatteVedtaksstegDto(emptyList())) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Håndterer behandlingens aktiv steg og fortsetter den til neste steg", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + opprettRequestContext("/api/behandling/${behandling.id}/steg/v1/", HttpMethod.POST, token) - val exception = shouldThrow { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } - - exception.message shouldBe "abc med rolle SAKSBEHANDLER har ikke tilgang til å Håndterer behandlingens aktiv " + - "steg og fortsetter den til neste steg. Krever BESLUTTER." + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.SAKSBEHANDLER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal beslutter ha tilgang i Fattevedtak utførBehandlingssteg POST request`() { - val token = opprettToken("abc", listOf(BARNETRYGD_BESLUTTER_ROLLE)) - // POST request uten body - opprettRequestContext("/api/behandling/$behandling.id/steg/v1/", HttpMethod.POST, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id, BehandlingsstegFatteVedtaksstegDto(emptyList())) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Håndterer behandlingens aktiv steg og fortsetter den til neste steg", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(BARNETRYGD_BESLUTTER_ROLLE)) + opprettRequestContext("/api/behandling/${behandling.id}/steg/v1/", HttpMethod.POST, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.SAKSBEHANDLER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal ha tilgang i sett behandling på vent PUT request`() { - val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE)) - opprettRequestContext("/api/behandling/$behandling.id/vent/v1/", HttpMethod.PUT, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns - arrayOf( - behandling.id, - BehandlingPåVentDto( - Venteårsak.VENT_PÅ_BRUKERTILBAKEMELDING, - LocalDate.now().plusWeeks(2), - ), - ) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Setter behandling på vent", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE)) + opprettRequestContext("/api/behandling/${behandling.id}/vent/v1/", HttpMethod.PUT, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.SAKSBEHANDLER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal forvalter ikke ha tilgang til vanlig tjenester`() { - val token = opprettToken("abc", listOf(TEAMFAMILIE_FORVALTER_ROLLE)) - opprettRequestContext("/api/behandling/$behandling.id/vent/v1/", HttpMethod.PUT, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns - arrayOf( - behandling.id, - BehandlingPåVentDto( - Venteårsak.VENT_PÅ_BRUKERTILBAKEMELDING, - LocalDate.now().plusWeeks(2), - ), - ) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Setter behandling på vent", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(TEAMFAMILIE_FORVALTER_ROLLE)) + opprettRequestContext("/api/behandling/${behandling.id}/vent/v1/", HttpMethod.PUT, token) - val exception = shouldThrow { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + val exception = shouldThrow { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.SAKSBEHANDLER, AuditLoggerEvent.ACCESS, "test") } - exception.message shouldBe "abc med rolle FORVALTER har ikke tilgang til å Setter behandling på vent." + - " Krever SAKSBEHANDLER." + exception.message shouldBe "abc med rolle FORVALTER har ikke tilgang til å test. Krever SAKSBEHANDLER." } @Test fun `sjekkTilgang skal saksbehandler ikke ha tilgang til forvaltningstjenester`() { - val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE)) - opprettRequestContext("/api/forvaltning//behandling/$behandling.id/tving-henleggelse/v1", HttpMethod.PUT, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Tving henlegger behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE)) + opprettRequestContext("/api/forvaltning/behandling/${behandling.id}/tving-henleggelse/v1", HttpMethod.PUT, token) - val exception = shouldThrow { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + val exception = shouldThrow { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.FORVALTER, AuditLoggerEvent.ACCESS, "test") } - exception.message shouldBe "abc med rolle SAKSBEHANDLER har ikke tilgang til å kalle forvaltningstjeneste " + - "Tving henlegger behandling. Krever FORVALTER." + exception.message shouldBe "abc med rolle SAKSBEHANDLER har ikke tilgang til å kalle forvaltningstjeneste test. Krever FORVALTER." } @Test fun `sjekkTilgang skal saksbehandler ha tilgang til forvaltningstjenester hvis saksbehandler har forvalter rolle også`() { val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE, TEAMFAMILIE_FORVALTER_ROLLE)) - opprettRequestContext("/api/forvaltning//behandling/$behandling.id/tving-henleggelse/v1", HttpMethod.PUT, token) + opprettRequestContext("/api/forvaltning/behandling/${behandling.id}/tving-henleggelse/v1", HttpMethod.PUT, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Tving henlegger behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.SAKSBEHANDLER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal saksbehandler ha tilgang til vanlig tjenester selv om saksbehandler har forvalter rolle også`() { - val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE, TEAMFAMILIE_FORVALTER_ROLLE)) - opprettRequestContext("/api/behandling/$behandling.id/vent/v1/", HttpMethod.PUT, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns - arrayOf( - behandling.id, - BehandlingPåVentDto( - Venteårsak.VENT_PÅ_BRUKERTILBAKEMELDING, - LocalDate.now().plusWeeks(2), - ), - ) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.SAKSBEHANDLER, - "Setter behandling på vent", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(BARNETRYGD_SAKSBEHANDLER_ROLLE, TEAMFAMILIE_FORVALTER_ROLLE)) + opprettRequestContext("/api/behandling/${behandling.id}/vent/v1/", HttpMethod.PUT, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.SAKSBEHANDLER, AuditLoggerEvent.ACCESS, "test") } } @Test fun `sjekkTilgang skal forvalter ha tilgang til forvaltningstjenester`() { - val token = opprettToken("abc", listOf(TEAMFAMILIE_FORVALTER_ROLLE)) - // POST request uten body - opprettRequestContext("/api/forvaltning//behandling/$behandling.id/tving-henleggelse/v1", HttpMethod.PUT, token) every { mockIntegrasjonerClient.sjekkTilgangTilPersoner(listOf("1232"), any()) } returns listOf(Tilgang(personIdent, true, null)) - every { mockJoinpoint.args } returns arrayOf(behandling.id) - val rolletilgangssjekk = - Rolletilgangssjekk( - Behandlerrolle.FORVALTER, - "Tving henlegger behandling", - AuditLoggerEvent.ACCESS, - HenteParam.BEHANDLING_ID, - ) + val token = opprettToken("abc", listOf(TEAMFAMILIE_FORVALTER_ROLLE)) + opprettRequestContext("/api/forvaltning/behandling/${behandling.id}/tving-henleggelse/v1", HttpMethod.PUT, token) - shouldNotThrowAny { tilgangAdvice.sjekkTilgang(mockJoinpoint, rolletilgangssjekk) } + shouldNotThrowAny { tilgangAdvice.validerTilgangBehandlingID(behandling.id, Behandlerrolle.FORVALTER, AuditLoggerEvent.ACCESS, "test") } } @Test