Slå sammen perioder i brev dersom de er like

src/main/kotlin/no/nav/familie/tilbake/api/DokumentController.kt

@@ -97,8 +97,8 @@ class DokumentController(
     @Rolletilgangssjekk(Behandlerrolle.SAKSBEHANDLER, "Forhåndsviser brev", AuditLoggerEvent.ACCESS)
     fun hentForhåndsvisningVedtaksbrev(
         @Valid @RequestBody
-        dto: HentForhåndvisningVedtaksbrevPdfDto,
-    ): Ressurs<ByteArray> = Ressurs.success(vedtaksbrevService.hentForhåndsvisningVedtaksbrevMedVedleggSomPdf(dto))
+        hentForhåndsvisningVedtaksbrevRequest: HentForhåndvisningVedtaksbrevPdfDto,
+    ): Ressurs<ByteArray> = Ressurs.success(vedtaksbrevService.hentForhåndsvisningVedtaksbrevMedVedleggSomPdf(hentForhåndsvisningVedtaksbrevRequest))
 
     @Operation(summary = "Hent vedtaksbrevtekst")
     @GetMapping(

src/main/kotlin/no/nav/familie/tilbake/api/PerioderController.kt

@@ -2,29 +2,38 @@ package no.nav.familie.tilbake.api
 
 import io.swagger.v3.oas.annotations.Operation
 import no.nav.familie.kontrakter.felles.Ressurs
-import no.nav.familie.tilbake.faktaomfeilutbetaling.FaktaFeilutbetalingService
-import no.nav.familie.tilbake.foreldelse.ForeldelseService
+import no.nav.familie.kontrakter.felles.Tema
+import no.nav.familie.tilbake.behandling.FagsakRepository
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.PeriodeService
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.VedtaksbrevService
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.VedtaksbrevsoppsummeringRepository
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.domain.Vedtaksbrevsoppsummering
 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.vilkårsvurdering.VilkårsvurderingService
 import no.nav.security.token.support.core.api.ProtectedWithClaims
+import org.slf4j.LoggerFactory
 import org.springframework.http.MediaType
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
+import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
 import java.util.UUID
 
 @RestController
 @RequestMapping("/api/perioder")
 @ProtectedWithClaims(issuer = "azuread")
 class PerioderController(
-    private val faktaFeilutbetalingService: FaktaFeilutbetalingService,
-    private val vilkårsVurderingService: VilkårsvurderingService,
-    private val foreldelseService: ForeldelseService,
+    private val vedtaksbrevService: VedtaksbrevService,
+    private val vedtaksbrevsoppsummeringRepository: VedtaksbrevsoppsummeringRepository,
+    private val fagsakRepository: FagsakRepository,
+    private val periodeService: PeriodeService,
 ) {
+    private val logger = LoggerFactory.getLogger(this::class.java)
+
     @Operation(summary = "Sjekker om perioder er like - unntatt dato og beløp")
     @GetMapping(
         "/sjekk-likhet/{behandlingId}",
@@ -38,10 +47,63 @@ class PerioderController(
     )
     fun erPerioderLike(
         @PathVariable behandlingId: UUID,
-    ): Ressurs<Boolean> =
-        Ressurs.success(
-            faktaFeilutbetalingService.sjekkOmFaktaPerioderErLike(behandlingId) &&
-                foreldelseService.sjekkOmForeldelsePerioderErLike(behandlingId) &&
-                vilkårsVurderingService.sjekkOmVilkårsvurderingPerioderErLike(behandlingId),
+    ): Ressurs<Boolean> {
+        val erEnsligForsørgerOgPerioderLike = periodeService.erEnsligForsørgerOgPerioderLike(behandlingId)
+
+        val vedtaksbrevsoppsummering = vedtaksbrevsoppsummeringRepository.findByBehandlingId(behandlingId)
+
+        if (!erEnsligForsørgerOgPerioderLike && vedtaksbrevsoppsummering != null) {
+            vedtaksbrevsoppsummeringRepository.update(vedtaksbrevsoppsummering.copy(skalSammenslåPerioder = false))
+        }
+        if (vedtaksbrevsoppsummering == null) {
+            vedtaksbrevsoppsummeringRepository.insert(Vedtaksbrevsoppsummering(UUID.randomUUID(), behandlingId, null, erEnsligForsørgerOgPerioderLike))
+        }
+
+        return Ressurs.success(
+            erEnsligForsørgerOgPerioderLike,
         )
+    }
+
+    @Operation(summary = "Oppdatere skalSammenslåPerioder")
+    @PostMapping(
+        "/sammensla/{behandlingId}",
+        produces = [MediaType.APPLICATION_JSON_VALUE],
+    )
+    @Rolletilgangssjekk(
+        Behandlerrolle.SAKSBEHANDLER,
+        "Oppdatere skalSammenslåPerioder",
+        AuditLoggerEvent.UPDATE,
+        HenteParam.BEHANDLING_ID,
+    )
+    fun samenslå(
+        @PathVariable behandlingId: UUID,
+    ): Ressurs<Boolean> {
+        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")
+        }
+        vedtaksbrevService.oppdaterSkalSammenslåPerioder(behandlingId, true)
+        return Ressurs.success(true)
+    }
+
+    @Operation(summary = "Angre sammenslå av perioder")
+    @PostMapping(
+        "/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<Boolean> {
+        val vedtaksbrevsoppsummering = vedtaksbrevsoppsummeringRepository.findByBehandlingId(behandlingId)
+        if (vedtaksbrevsoppsummering != null) {
+            vedtaksbrevsoppsummeringRepository.update(vedtaksbrevsoppsummering.copy(skalSammenslåPerioder =  false))
+        }
+        return Ressurs.success(true)
+    }
 }

src/main/kotlin/no/nav/familie/tilbake/behandling/steg/Vilkårsvurderingssteg.kt

@@ -10,6 +10,9 @@ import no.nav.familie.tilbake.behandlingskontroll.domain.Behandlingsstegstatus
 import no.nav.familie.tilbake.behandlingskontroll.domain.Behandlingsstegstatus.AUTOUTFØRT
 import no.nav.familie.tilbake.behandlingskontroll.domain.Behandlingsstegstatus.UTFØRT
 import no.nav.familie.tilbake.common.exceptionhandler.Feil
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.PeriodeService
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.VedtaksbrevsoppsummeringRepository
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.domain.Vedtaksbrevsoppsummering
 import no.nav.familie.tilbake.foreldelse.ForeldelseService
 import no.nav.familie.tilbake.historikkinnslag.Aktør
 import no.nav.familie.tilbake.historikkinnslag.HistorikkTaskService
@@ -31,6 +34,8 @@ class Vilkårsvurderingssteg(
     private val foreldelseService: ForeldelseService,
     private val historikkTaskService: HistorikkTaskService,
     private val oppgaveTaskService: OppgaveTaskService,
+    private val periodeService: PeriodeService,
+    private val vedtaksbrevsoppsummeringRepository: VedtaksbrevsoppsummeringRepository,
 ) : IBehandlingssteg {
     private val logger = LoggerFactory.getLogger(this::class.java)
 
@@ -65,7 +70,7 @@ class Vilkårsvurderingssteg(
             )
         }
         vilkårsvurderingService.lagreVilkårsvurdering(behandlingId, behandlingsstegDto as BehandlingsstegVilkårsvurderingDto)
-
+        oppdatereVedtaksbrevsoppsummering(behandlingId)
         oppgaveTaskService.oppdaterAnsvarligSaksbehandlerOppgaveTask(behandlingId)
 
         lagHistorikkinnslag(behandlingId, Aktør.SAKSBEHANDLER)
@@ -127,4 +132,17 @@ class Vilkårsvurderingssteg(
             aktør,
         )
     }
+
+    private fun oppdatereVedtaksbrevsoppsummering(behandlingId: UUID) {
+        val erEnsligForsørgerOgPerioderLike = periodeService.erEnsligForsørgerOgPerioderLike(behandlingId)
+        val vedtaksbrevsoppsummering = vedtaksbrevsoppsummeringRepository.findByBehandlingId(behandlingId)
+
+        if (vedtaksbrevsoppsummering != null) {
+            vedtaksbrevsoppsummeringRepository.update(vedtaksbrevsoppsummering.copy(skalSammenslåPerioder = erEnsligForsørgerOgPerioderLike))
+        }
+
+        if (erEnsligForsørgerOgPerioderLike && vedtaksbrevsoppsummering == null) {
+            vedtaksbrevsoppsummeringRepository.insert(Vedtaksbrevsoppsummering(behandlingId = behandlingId, skalSammenslåPerioder = erEnsligForsørgerOgPerioderLike, oppsummeringFritekst = null))
+        }
+    }
 }

src/main/kotlin/no/nav/familie/tilbake/dokumentbestilling/vedtak/Avsnitt.kt

@@ -5,6 +5,7 @@ import java.time.LocalDate
 enum class Avsnittstype {
     OPPSUMMERING,
     PERIODE,
+    SAMMENSLÅTT_PERIODE,
     TILLEGGSINFORMASJON,
 }
 

src/main/kotlin/no/nav/familie/tilbake/dokumentbestilling/vedtak/AvsnittUtil.kt

@@ -1,26 +1,30 @@
 package no.nav.familie.tilbake.dokumentbestilling.vedtak
 
+import no.nav.familie.kontrakter.felles.Datoperiode
 import no.nav.familie.tilbake.dokumentbestilling.handlebars.FellesTekstformaterer
 import no.nav.familie.tilbake.dokumentbestilling.vedtak.handlebars.dto.HbVedtaksbrevFelles
 import no.nav.familie.tilbake.dokumentbestilling.vedtak.handlebars.dto.HbVedtaksbrevPeriodeOgFelles
 import no.nav.familie.tilbake.dokumentbestilling.vedtak.handlebars.dto.HbVedtaksbrevsdata
 import no.nav.familie.tilbake.dokumentbestilling.vedtak.handlebars.dto.Vedtaksbrevstype
+import no.nav.familie.tilbake.dokumentbestilling.vedtak.handlebars.dto.periode.HbVedtaksbrevsperiode
 
 internal object AvsnittUtil {
     const val PARTIAL_PERIODE_FAKTA = "vedtak/periode_fakta"
+    const val PARTIAL_PERIODE_FAKTA_SAMMENSLÅTT_PERIODER = "vedtak/periode-fakta/periode_fakta_ef_sammenslå_perioder"
     const val PARTIAL_PERIODE_FORELDELSE = "vedtak/periode_foreldelse"
     const val PARTIAL_PERIODE_VILKÅR = "vedtak/periode_vilkår"
     const val PARTIAL_PERIODE_SÆRLIGE_GRUNNER = "vedtak/periode_særlige_grunner"
 
     fun lagVedtaksbrevDeltIAvsnitt(
         vedtaksbrevsdata: HbVedtaksbrevsdata,
         hovedoverskrift: String,
+        skalSammenslåPerioder: Boolean = false,
     ): List<Avsnitt> {
         val resultat: MutableList<Avsnitt> = ArrayList()
         val vedtaksbrevsdataMedFriteksmarkeringer = Vedtaksbrevsfritekst.settInnMarkeringForFritekst(vedtaksbrevsdata)
         resultat.add(lagOppsummeringsavsnitt(vedtaksbrevsdataMedFriteksmarkeringer, hovedoverskrift))
         if (vedtaksbrevsdata.felles.vedtaksbrevstype == Vedtaksbrevstype.ORDINÆR) {
-            resultat.addAll(lagPerioderavsnitt(vedtaksbrevsdataMedFriteksmarkeringer))
+            resultat.addAll(lagPerioderavsnitt(vedtaksbrevsdataMedFriteksmarkeringer, skalSammenslåPerioder))
         }
         resultat.add(lagAvsluttendeAvsnitt(vedtaksbrevsdataMedFriteksmarkeringer))
         return resultat
@@ -45,10 +49,18 @@ internal object AvsnittUtil {
         return FellesTekstformaterer.lagDeltekst(vedtaksbrevFelles, filsti)
     }
 
-    private fun lagPerioderavsnitt(vedtaksbrevsdata: HbVedtaksbrevsdata): List<Avsnitt> =
-        vedtaksbrevsdata.perioder.map {
-            lagPeriodeAvsnitt(HbVedtaksbrevPeriodeOgFelles(vedtaksbrevsdata.felles, it))
+    private fun lagPerioderavsnitt(
+        vedtaksbrevsdata: HbVedtaksbrevsdata,
+        skalSammenslåPerioder: Boolean,
+    ): List<Avsnitt> {
+        if (skalSammenslåPerioder) {
+            return listOf(lagSammenslåttPeriodeAvsnitt(vedtaksbrevsdata))
+        } else {
+            return vedtaksbrevsdata.perioder.map {
+                lagPeriodeAvsnitt(HbVedtaksbrevPeriodeOgFelles(vedtaksbrevsdata.felles, it))
+            }
         }
+    }
 
     private fun lagAvsluttendeAvsnitt(vedtaksbrevsdata: HbVedtaksbrevsdata): Avsnitt {
         val tekst = FellesTekstformaterer.lagDeltekst(vedtaksbrevsdata, "vedtak/vedtak_slutt")
@@ -79,6 +91,41 @@ internal object AvsnittUtil {
         return avsnitt
     }
 
+    private fun lagSammenslåttPeriodeAvsnitt(vedtaksbrevsdata: HbVedtaksbrevsdata): Avsnitt {
+        val førstePeriode = vedtaksbrevsdata.perioder.first()
+        val sammenslåttDatoperiode =
+            Datoperiode(
+                førstePeriode.periode.fom,
+                vedtaksbrevsdata.perioder
+                    .last()
+                    .periode.tom,
+            )
+        val hbVedtaksbrevsperiode = HbVedtaksbrevsperiode(sammenslåttDatoperiode, førstePeriode.kravgrunnlag, førstePeriode.fakta, førstePeriode.vurderinger, førstePeriode.resultat, true, førstePeriode.grunnbeløp)
+        val hbVedtaksbrevPeriodeOgFelles = HbVedtaksbrevPeriodeOgFelles(vedtaksbrevsdata.felles, hbVedtaksbrevsperiode)
+
+        var avsnitt =
+            Avsnitt(
+                avsnittstype = Avsnittstype.SAMMENSLÅTT_PERIODE,
+                overskrift = "Perioder som er feilutbetalt",
+                fom = førstePeriode.periode.fom,
+                tom = førstePeriode.periode.tom,
+            )
+
+        val faktatekst = FellesTekstformaterer.lagDeltekst(vedtaksbrevsdata, PARTIAL_PERIODE_FAKTA_SAMMENSLÅTT_PERIODER)
+        val foreldelsestekst = FellesTekstformaterer.lagDeltekst(hbVedtaksbrevPeriodeOgFelles, PARTIAL_PERIODE_FORELDELSE)
+        val vilkårstekst = FellesTekstformaterer.lagDeltekst(hbVedtaksbrevPeriodeOgFelles, PARTIAL_PERIODE_VILKÅR)
+        val særligeGrunnerstekst = FellesTekstformaterer.lagDeltekst(hbVedtaksbrevPeriodeOgFelles, PARTIAL_PERIODE_SÆRLIGE_GRUNNER)
+        val avsluttendeTekst = FellesTekstformaterer.lagDeltekst(hbVedtaksbrevPeriodeOgFelles, "vedtak/periode_slutt")
+
+        avsnitt = parseTekst(faktatekst, avsnitt, Underavsnittstype.FAKTA)
+        avsnitt = parseTekst(foreldelsestekst, avsnitt, Underavsnittstype.FORELDELSE)
+        avsnitt = parseTekst(vilkårstekst, avsnitt, Underavsnittstype.VILKÅR)
+        avsnitt = parseTekst(særligeGrunnerstekst, avsnitt, Underavsnittstype.SÆRLIGEGRUNNER)
+        avsnitt = parseTekst(avsluttendeTekst, avsnitt, null)
+
+        return avsnitt
+    }
+
     fun parseTekst(
         generertTekst: String,
         avsnitt: Avsnitt,

src/main/kotlin/no/nav/familie/tilbake/dokumentbestilling/vedtak/PeriodeService.kt

@@ -0,0 +1,25 @@
+package no.nav.familie.tilbake.dokumentbestilling.vedtak
+
+import no.nav.familie.kontrakter.felles.Tema
+import no.nav.familie.tilbake.behandling.FagsakRepository
+import no.nav.familie.tilbake.faktaomfeilutbetaling.FaktaFeilutbetalingService
+import no.nav.familie.tilbake.foreldelse.ForeldelseService
+import no.nav.familie.tilbake.vilkårsvurdering.VilkårsvurderingService
+import org.springframework.stereotype.Service
+import java.util.UUID
+
+@Service
+class PeriodeService(
+    private val faktaFeilutbetalingService: FaktaFeilutbetalingService,
+    private val foreldelseService: ForeldelseService,
+    private val vilkårsvurderingService: VilkårsvurderingService,
+    private val fagsakRepository: FagsakRepository,
+) {
+    fun erEnsligForsørgerOgPerioderLike(behandlingId: UUID): Boolean {
+        val fagsak = fagsakRepository.finnFagsakForBehandlingId(behandlingId)
+        return faktaFeilutbetalingService.sjekkOmFaktaPerioderErLike(behandlingId) &&
+            foreldelseService.sjekkOmForeldelsePerioderErLike(behandlingId) &&
+            vilkårsvurderingService.sjekkOmVilkårsvurderingPerioderErLike(behandlingId) &&
+            fagsak.ytelsestype.tilTema() == Tema.ENF
+    }
+}

src/main/kotlin/no/nav/familie/tilbake/dokumentbestilling/vedtak/TekstformatererVedtaksbrev.kt

@@ -7,11 +7,18 @@ import no.nav.familie.tilbake.dokumentbestilling.vedtak.handlebars.dto.Vedtaksbr
 internal object TekstformatererVedtaksbrev {
     fun lagVedtaksbrevsfritekst(
         vedtaksbrevsdata: HbVedtaksbrevsdata,
+        skalSammenslåPerioder: Boolean = false,
+        erPerioderLike: Boolean = false,
     ): String =
         when (vedtaksbrevsdata.felles.vedtaksbrevstype) {
             Vedtaksbrevstype.FRITEKST_FEILUTBETALING_BORTFALT ->
                 lagVedtaksbrev("vedtak/fritekstFeilutbetalingBortfalt/fritekstFeilutbetalingBortfalt", vedtaksbrevsdata)
-            Vedtaksbrevstype.ORDINÆR -> lagVedtaksbrev("vedtak/vedtak", vedtaksbrevsdata)
+            Vedtaksbrevstype.ORDINÆR ->
+                if (skalSammenslåPerioder && erPerioderLike) {
+                    lagVedtaksbrev("vedtak/vedtak_sammenslå_perioder", vedtaksbrevsdata)
+                } else {
+                    lagVedtaksbrev("vedtak/vedtak", vedtaksbrevsdata)
+                }
             Vedtaksbrevstype.AUTOMATISK_4X_RETTSGEBYR -> lagVedtaksbrev("vedtak/vedtak_feilutbetaling_under_4x_rettsgebyr", vedtaksbrevsdata)
         }
 

src/main/kotlin/no/nav/familie/tilbake/dokumentbestilling/vedtak/VedtaksbrevFritekstMapper.kt

@@ -11,10 +11,12 @@ object VedtaksbrevFritekstMapper {
     fun tilDomene(
         behandlingId: UUID,
         oppsummeringstekst: String?,
+        skalSammenslåPerioder: Boolean,
     ): Vedtaksbrevsoppsummering =
         Vedtaksbrevsoppsummering(
             behandlingId = behandlingId,
             oppsummeringFritekst = oppsummeringstekst,
+            skalSammenslåPerioder = skalSammenslåPerioder,
         )
 
     fun tilDomeneVedtaksbrevsperiode(

src/main/kotlin/no/nav/familie/tilbake/dokumentbestilling/vedtak/VedtaksbrevFritekstValidator.kt

@@ -38,6 +38,7 @@ object VedtaksbrevFritekstValidator {
                     it,
                     vedtaksbrevFritekstPerioder,
                     validerPåkrevetFritekster,
+                    vedtaksbrevsoppsummering.skalSammenslåPerioder,
                 )
             }
         }
@@ -48,6 +49,7 @@ object VedtaksbrevFritekstValidator {
                 vedtaksbrevFritekstPerioder,
                 avsnittMedPerioder,
                 validerPåkrevetFritekster,
+                vedtaksbrevsoppsummering.skalSammenslåPerioder,
             )
         }
         validerOppsummeringsfritekstLengde(behandling, vedtaksbrevsoppsummering, vedtaksbrevstype)
@@ -127,9 +129,12 @@ object VedtaksbrevFritekstValidator {
         vedtaksbrevFritekstPerioder: List<Vedtaksbrevsperiode>,
         avsnittMedPerioder: List<PeriodeMedTekstDto>,
         validerPåkrevetFritekster: Boolean,
+        skalSammenslåPerioder: Boolean,
     ) {
-        faktaFeilutbetaling.perioder
-            .filter { Hendelsesundertype.ANNET_FRITEKST == it.hendelsesundertype }
+        val faktaPerioderMedFritekst = faktaFeilutbetaling.perioder.filter { Hendelsesundertype.ANNET_FRITEKST == it.hendelsesundertype }.sortedBy { it.periode }
+        val validerPerioder = if (skalSammenslåPerioder && faktaPerioderMedFritekst.isNotEmpty()) listOf(faktaPerioderMedFritekst.first()) else faktaPerioderMedFritekst
+
+        validerPerioder
             .forEach { faktaFeilutbetalingsperiode ->
                 val perioder =
                     finnFritekstPerioder(
@@ -165,13 +170,24 @@ object VedtaksbrevFritekstValidator {
         vilkårsvurdering: Vilkårsvurdering,
         vedtaksbrevFritekstPerioder: List<Vedtaksbrevsperiode>,
         validerPåkrevetFritekster: Boolean,
+        skalSammenslåPerioder: Boolean,
     ) {
-        vilkårsvurdering.perioder
-            .filter {
-                it.aktsomhet?.vilkårsvurderingSærligeGrunner != null &&
-                    it.aktsomhet.vilkårsvurderingSærligeGrunner
-                        .any { særligGrunn -> SærligGrunn.ANNET == særligGrunn.særligGrunn }
-            }.forEach {
+        val perioderMedSærligeGrunner =
+            vilkårsvurdering.perioder
+                .filter {
+                    it.aktsomhet?.vilkårsvurderingSærligeGrunner != null &&
+                        it.aktsomhet.vilkårsvurderingSærligeGrunner.any { særligGrunn -> SærligGrunn.ANNET == særligGrunn.særligGrunn }
+                }.sortedBy { it.periode }
+
+        val validerPerioder =
+            if (skalSammenslåPerioder && perioderMedSærligeGrunner.isNotEmpty()) {
+                setOf(perioderMedSærligeGrunner.first())
+            } else {
+                perioderMedSærligeGrunner
+            }
+
+        validerPerioder
+            .forEach {
                 val perioder =
                     finnFritekstPerioder(
                         vedtaksbrevFritekstPerioder,