Tjeneste til Pensjon for uthenting av perioder med barnetrygd

src/main/kotlin/no/nav/familie/ba/infotrygd/repository/SakRepository.kt

@@ -47,6 +47,16 @@ interface SakRepository : JpaRepository<Sak, Long> {
     )
     fun hentUtvidetBarnetrygdsakerForStønad(stonad: TrunkertStønad): List<Sak>
 
-
-
+    @Query(
+        """
+        SELECT s FROM Sak s 
+            WHERE s.personKey = :#{#stonad.personKey}
+              AND s.kapittelNr = 'BA'
+              AND s.valg IN ('OR','UT')
+              AND s.saksblokk = :#{#stonad.saksblokk}
+              AND s.saksnummer = :#{#stonad.sakNr}
+              AND s.region = :#{#stonad.region}
+              AND s.type IN ('S', 'R', 'K', 'A', 'FL', 'AS')"""
+    )
+    fun hentBarnetrygdsakerForStønad(stonad: TrunkertStønad): List<Sak>
 }

src/main/kotlin/no/nav/familie/ba/infotrygd/rest/controller/PensjonController.kt

@@ -0,0 +1,96 @@
+package no.nav.familie.ba.infotrygd.rest.controller
+
+import com.fasterxml.jackson.annotation.JsonProperty
+import io.micrometer.core.annotation.Timed
+import io.swagger.v3.oas.annotations.Operation
+import io.swagger.v3.oas.annotations.Parameter
+import io.swagger.v3.oas.annotations.media.Content
+import io.swagger.v3.oas.annotations.media.ExampleObject
+import io.swagger.v3.oas.annotations.media.Schema
+import no.nav.commons.foedselsnummer.FoedselsNr
+import no.nav.familie.ba.infotrygd.service.BarnetrygdService
+import no.nav.familie.ba.infotrygd.service.ClientValidator
+import no.nav.security.token.support.core.api.Protected
+import org.springframework.http.HttpStatus
+import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+import org.springframework.web.server.ResponseStatusException
+import java.time.LocalDate
+import java.time.YearMonth
+import io.swagger.v3.oas.annotations.parameters.RequestBody as ApiRequestBody
+
+@Protected
+@RestController
+@Timed(value = "infotrygd_historikk_pensjon_controller", percentiles = [0.5, 0.95])
+@RequestMapping("/infotrygd/barnetrygd")
+class PensjonController(
+    private val barnetrygdService: BarnetrygdService,
+    private val clientValidator: ClientValidator,
+) {
+
+    @Operation(summary = "Uttrekk barnetrygdperioder på en person fra en bestemet måned. Maks 2 år tilbake i tid")
+    @PostMapping(path = ["pensjon"], consumes = ["application/json"])
+    @ApiRequestBody(content = [Content(examples = [ExampleObject(value = """{"ident": "12345678910", "fraDato": "2022-12-01"}""")])])
+    fun hentBarnetrygd(@RequestBody request: BarnetrygdTilPensjonRequest): BarnetrygdTilPensjonResponse {
+        clientValidator.authorizeClient()
+
+        val fraDato = YearMonth.of(request.fraDato.year, request.fraDato.month)
+
+        if (fraDato.isBefore(YearMonth.now().minusYears(2))) {
+            throw ResponseStatusException(HttpStatus.BAD_REQUEST, "fraDato kan ikke være lenger enn 2 år tilbake i tid")
+        }
+
+        val bruker = FoedselsNr(request.ident)
+
+        return BarnetrygdTilPensjonResponse(
+            saker = barnetrygdService.finnBarnetrygdForPensjon(bruker, fraDato)
+        )
+    }
+
+    @Operation(summary = "Finner alle personer med barnetrygd innenfor et bestemt år på vegne av Psys")
+    @GetMapping(path = ["pensjon"])
+    fun personerMedBarnetrygd(@Parameter(name = "aar") @RequestParam("aar") år: String): List<FoedselsNr> {
+        clientValidator.authorizeClient()
+        return barnetrygdService.finnPersonerBarnetrygdPensjon(år)
+    }
+
+
+    data class BarnetrygdTilPensjonRequest(
+        val ident: String,
+        @Schema(implementation = String::class, example = "2020-12-01") val fraDato: LocalDate,
+    )
+
+    data class BarnetrygdTilPensjonResponse(
+        @JsonProperty("fagsaker") val saker: List<BarnetrygdTilPensjon>
+    )
+
+    data class BarnetrygdTilPensjon(
+        @JsonProperty("fagsakEiersIdent") val fnr: String,
+        val barnetrygdPerioder: List<BarnetrygdPeriode>,
+    )
+
+    data class BarnetrygdPeriode(
+        val personIdent: String,
+        val delingsprosentYtelse: YtelseProsent,
+        val ytelseTypeEkstern: YtelseTypeEkstern?,
+        val stønadFom: YearMonth,
+        val stønadTom: YearMonth,
+        val kildesystem: String = "Infotrygd"
+    )
+
+    enum class YtelseTypeEkstern {
+        ORDINÆR_BARNETRYGD,
+        UTVIDET_BARNETRYGD,
+        SMÅBARNSTILLEGG,
+    }
+
+    enum class YtelseProsent {
+        FULL,
+        DELT,
+        USIKKER
+    }
+}

src/main/kotlin/no/nav/familie/ba/infotrygd/service/BarnetrygdService.kt

@@ -21,6 +21,10 @@ import no.nav.familie.ba.infotrygd.rest.controller.BisysController.InfotrygdUtvi
 import no.nav.familie.ba.infotrygd.rest.controller.BisysController.Stønadstype.SMÅBARNSTILLEGG
 import no.nav.familie.ba.infotrygd.rest.controller.BisysController.Stønadstype.UTVIDET
 import no.nav.familie.ba.infotrygd.rest.controller.BisysController.UtvidetBarnetrygdPeriode
+import no.nav.familie.ba.infotrygd.rest.controller.PensjonController.BarnetrygdPeriode
+import no.nav.familie.ba.infotrygd.rest.controller.PensjonController.BarnetrygdTilPensjon
+import no.nav.familie.ba.infotrygd.rest.controller.PensjonController.YtelseProsent
+import no.nav.familie.ba.infotrygd.rest.controller.PensjonController.YtelseTypeEkstern
 import no.nav.familie.ba.infotrygd.utils.DatoUtils
 import no.nav.familie.ba.infotrygd.utils.DatoUtils.isSameOrAfter
 import no.nav.familie.eksterne.kontrakter.skatteetaten.SkatteetatenPeriode
@@ -33,6 +37,7 @@ import org.springframework.core.env.Environment
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.PageRequest
 import org.springframework.stereotype.Service
+import java.time.LocalDate
 import java.time.LocalDateTime
 import java.time.YearMonth
 import java.time.format.DateTimeFormatter
@@ -151,6 +156,31 @@ class BarnetrygdService(
         return personer.map { person -> vedtakRepository.tellAntallÅpneSakerPåPerson(person) }.sum()
     }
 
+    fun finnBarnetrygdForPensjon(
+        brukerFnr: FoedselsNr,
+        fraDato: YearMonth
+    ): List<BarnetrygdTilPensjon> {
+        val barnetrygdStønader = stonadRepository.findStønadByFnr(listOf(brukerFnr)).filter { it.antallBarn > 0 }
+            .map { it.tilTrunkertStønad() }
+            .filter { erRelevantStønadForPensjon(it) }
+            .filter { filtrerStønaderSomErFeilregistrert(it) }
+
+        val perioder = konverterTilDtoForPensjon(barnetrygdStønader, fraDato.year).filter {
+            skalFiltreresPåDato(fraDato, it.stønadFom, it.stønadTom)
+        }
+
+        if (perioder.isEmpty()) {
+            return emptyList()
+        }
+
+        return listOf(
+            BarnetrygdTilPensjon(
+                fnr = brukerFnr.asString,
+                barnetrygdPerioder = perioder
+            )
+        )
+    }
+
     fun finnUtvidetBarnetrygdBisys(
         brukerFnr: FoedselsNr,
         fraDato: YearMonth
@@ -219,6 +249,23 @@ class BarnetrygdService(
         }
     }
 
+    @Cacheable(cacheManager = "personerCacheManager", value = ["pensjon_personer"], unless = "#result == null")
+    fun finnPersonerBarnetrygdPensjon(år: String): List<FoedselsNr> {
+        val stønaderMedAktuelleKoder = stonadRepository.findStønadByÅrAndStatusKoder(år.toInt(), "00", "01", "02")
+            .filter { erRelevantStønadForPensjon(it) }
+            .filter { filtrerStønaderSomErFeilregistrert(it) }
+            .filter {
+                val sisteMåned = DatoUtils.stringDatoMMyyyyTilYearMonth(it.opphørtFom)?.minusMonths(1)
+                sisteMåned == null || sisteMåned.year >= år.toInt()
+            }
+            .filter {
+                utbetalingRepository.hentUtbetalingerByStønad(it).any { it.tom() == null || it.tom()!!.year >= år.toInt() }
+            }
+
+        return stønaderMedAktuelleKoder.mapNotNull {
+            it.fnr
+        }
+    }
 
     fun listUtvidetStønadstyperForPerson(år: Int, fnr:String): List<String> {
         val utvidetBarnetrygdStønader = stonadRepository.findStønadByÅrAndStatusKoderAndFnr(FoedselsNr(fnr), år, "00", "02", "03").map { it.tilTrunkertStønad() }
@@ -314,6 +361,27 @@ class BarnetrygdService(
         }
     }
 
+    private fun erRelevantStønadForPensjon(
+        stønad: TrunkertStønad
+    ): Boolean {
+        return when (stønad.status.toLong()) {
+            0L -> { // Manuell beregning ved Stønadsklasse BA OR/UT MB/MD/ME.
+
+                if (stønad.fnr == null) {
+                    logger.info("stønad.fnr var null for stønad med id ${stønad.id}")
+                    return false
+                }
+                val undervalg = hentValgOgUndervalg(stønad).second
+                undervalg in arrayOf(MANUELL_BEREGNING, MANUELL_BEREGNING_DELT_BOSTED, MANUELL_BEREGNING_EØS)
+            }
+            1L -> true  // Ordinær barnetrygd - Maskinell beregning
+            2L -> true  // Utvidet barnetrygd - Maskinell beregning.
+            3L -> false // Sykt barn (Ikke lenger i bruk, kan forekomme i gamle tilfeller),
+            4L -> false // Ordinær barnetrygd - Institusjon
+            else -> false
+        }
+    }
+
 
     private fun konverterTilDtoUtvidetBarnetrygdForSkatteetaten(
         brukerFnr: FoedselsNr, utvidetBarnetrygdStønader: List<TrunkertStønad>, år: Int
@@ -365,6 +433,52 @@ class BarnetrygdService(
         }
     }
 
+    private fun konverterTilDtoForPensjon(
+        barnetrygdStønader: List<TrunkertStønad>,
+        år: Int
+    ): List<BarnetrygdPeriode> {
+        if (barnetrygdStønader.isEmpty()) {
+            return emptyList()
+        }
+
+        val allePerioder = mutableListOf<BarnetrygdPeriode>()
+
+        barnetrygdStønader.forEach {
+            val utbetalinger = utbetalingRepository.hentUtbetalingerByStønad(it)
+            allePerioder.addAll(utbetalinger.map { utbetaling ->
+
+                val (valg, undervalg) = hentValgOgUndervalg(it)
+
+                BarnetrygdPeriode(
+                    ytelseTypeEkstern = when {
+                        utbetaling.erSmåbarnstillegg() -> YtelseTypeEkstern.SMÅBARNSTILLEGG
+                        valg == "UT" -> YtelseTypeEkstern.UTVIDET_BARNETRYGD
+                        else -> YtelseTypeEkstern.ORDINÆR_BARNETRYGD
+                    },
+                    stønadFom = utbetaling.fom()!!,
+                    stønadTom = utbetaling.tom() ?: YearMonth.from(LocalDate.MAX),
+                    personIdent = utbetaling.fnr.asString,
+                    delingsprosentYtelse = ytelseProsent(it, undervalg, år)
+                )
+            })
+        }
+
+        val perioder =
+            allePerioder.filter { it.erOrdinærBarnetrygd }.groupBy { it.delingsprosentYtelse }.values
+                .flatMap(::slåSammenSammenhengende).toMutableList()
+
+        perioder.addAll(
+            allePerioder.filter { it.erUtvidetBarnetrygd }.groupBy { it.delingsprosentYtelse }.values
+                .flatMap(::slåSammenSammenhengende)
+        )
+        perioder.addAll(
+            allePerioder.filter { it.erSmåbarnstillegg }.groupBy { it.delingsprosentYtelse }.values
+                .flatMap(::slåSammenSammenhengende)
+        )
+
+        return perioder
+    }
+
     private fun delingsprosent(stønad: TrunkertStønad, år: Int): SkatteetatenPeriode.Delingsprosent {
         val undervalg = hentUndervalg(stønad)
         var delingsprosent = SkatteetatenPeriode.Delingsprosent.usikker
@@ -388,6 +502,27 @@ class BarnetrygdService(
         return delingsprosent
     }
 
+    private fun ytelseProsent(stønad: TrunkertStønad, undervalg: String?, år: Int): YtelseProsent {
+        if (stønad.status.toInt() != 0 ) {
+            return YtelseProsent.FULL
+        } else if (undervalg == MANUELL_BEREGNING_DELT_BOSTED) {
+            if (stønad.antallBarn == 1) {
+                return YtelseProsent.DELT
+            } else if (stønad.antallBarn < 7) {
+                val sumUtbetaltBeløp = utbetalingRepository.hentUtbetalingerByStønad(stønad).sumOf { it.beløp }
+                val gyldigeBeløp = utledListeMedGyldigeUtbetalingsbeløp(stønad.antallBarn, år)
+
+                if (gyldigeBeløp.contains(sumUtbetaltBeløp.roundToInt())) {
+                    return YtelseProsent.DELT
+                } else {
+                    secureLogger.info("Ytelseprosent usikker, ident ${stønad.fnr}, sumUtbetaltBeløp: $sumUtbetaltBeløp, gyldigeBeløp: $gyldigeBeløp" +
+                                              ", antallBarn: ${stønad.antallBarn}, år: $år")
+                }
+            }
+        }
+        return YtelseProsent.USIKKER
+    }
+
     fun utledListeMedGyldigeUtbetalingsbeløp(antallBarn: Int, år: Int): Set<Int> {
         val gyldigeBeløp = mutableSetOf<Int>()
         for (i in 0..antallBarn) {
@@ -467,6 +602,31 @@ class BarnetrygdService(
             hentUtvidetBarnetrygdUndervalgFraDb2(stønad).filterNotNull()
         }
 
+    private fun hentValgOgUndervalg(stønad: TrunkertStønad) =
+        sakRepository.hentBarnetrygdsakerForStønad(stønad).map {
+            it.valg to it.undervalg
+        }.filter { it.second != null }.ifEmpty {
+            hentBarnetrygdValgOgUndervalgFraDb2(stønad)
+        }.distinct().singleOrNull() ?: run {
+            secureLogger.info("Manglende/tvetydig stønadsklassifisering for stønad $stønad")
+            (null to null)
+        }
+
+    private fun slåSammenSammenhengende(perioderMedLikProsentandel: List<BarnetrygdPeriode>): List<BarnetrygdPeriode> {
+        require(perioderMedLikProsentandel.all { it.delingsprosentYtelse == perioderMedLikProsentandel.first().delingsprosentYtelse })
+
+        return perioderMedLikProsentandel.sortedBy { it.stønadFom }
+            .fold(mutableListOf()) { sammenslåttePerioder, nestePeriode ->
+                val forrigePeriode = sammenslåttePerioder.lastOrNull()
+
+                if (forrigePeriode?.stønadTom?.isSameOrAfter(nestePeriode.stønadFom.minusMonths(1)) == true) {
+                    sammenslåttePerioder.apply { add(removeLast().copy(stønadTom = nestePeriode.stønadTom)) }
+                } else {
+                    sammenslåttePerioder.apply { add(nestePeriode) }
+                }
+            }
+    }
+
     private fun slåSammenSammenhengendePerioder(utbetalingerAvEtGittBeløp: List<UtvidetBarnetrygdPeriode>): List<UtvidetBarnetrygdPeriode> {
         return utbetalingerAvEtGittBeløp.sortedBy { it.fomMåned }
             .fold(mutableListOf()) { sammenslåttePerioder, nesteUtbetaling ->
@@ -507,6 +667,19 @@ class BarnetrygdService(
             .map { it.kodeNivå3 }
     } ?: emptyList()
 
+    private fun hentBarnetrygdValgOgUndervalgFraDb2(
+        stønad: TrunkertStønad
+    ) = stønad.fnr?.let {
+        vedtakRepository.hentStønadsklassifisering(
+            fnr = stønad.fnr.asString,
+            tkNr = stønad.personKey.toString().padStart(15, '0').substring(0, 4),
+            saksblokk = stønad.saksblokk,
+            saksnummer = stønad.sakNr.toLong()
+        ).groupBy { stønadsklasse -> stønadsklasse.vedtakId }.values
+            .filter { !it.kodeNivå2.isNullOrBlank() }
+            .map { it.kodeNivå2!! to it.kodeNivå3 }
+    } ?: emptyList()
+
     private val List<Stønadsklasse>.kodeNivå2: String?
         get() {
             return find { it.kodeNivaa == "02" }?.kodeKlasse  // vil f.eks være "OR" for en sak av type BA OR OS
@@ -531,3 +704,12 @@ class BarnetrygdService(
         const val PREPROD = "preprod"
     }
 }
+
+private val BarnetrygdPeriode.erOrdinærBarnetrygd: Boolean
+    get() = ytelseTypeEkstern == YtelseTypeEkstern.ORDINÆR_BARNETRYGD
+
+private val BarnetrygdPeriode.erUtvidetBarnetrygd: Boolean
+    get() = ytelseTypeEkstern == YtelseTypeEkstern.UTVIDET_BARNETRYGD
+
+private val BarnetrygdPeriode.erSmåbarnstillegg: Boolean
+    get() = ytelseTypeEkstern == YtelseTypeEkstern.SMÅBARNSTILLEGG

src/test/kotlin/no/nav/familie/ba/infotrygd/repository/StønadRepositoryTest.kt

@@ -49,6 +49,26 @@ class StønadRepositoryTest {
         )
     }
 
+    @Test
+    fun `sjekk at antall personer med barnetrygd til pensjon er riktig innenfor hvert av årene 2021, 2022 og 2023`() {
+        stønadRepository.saveAll(listOf(
+            TestData.stønad(TestData.person(), opphørtFom = "122021", status = "01"), // ordinær barnetrygd opphørt 2021
+            TestData.stønad(TestData.person(), opphørtFom = "122022", status = "02"), // utvidet opphørt 2022
+            TestData.stønad(TestData.person(), status = "02") // løpende utvidet
+        )).also { stønader ->
+            utbetalingRepository.saveAll(stønader.map { TestData.utbetaling(it) })
+        }
+        barnetrygdService.finnPersonerBarnetrygdPensjon("2021").also {
+            assertThat(it).hasSize(3)
+        }
+        barnetrygdService.finnPersonerBarnetrygdPensjon("2022").also {
+            assertThat(it).hasSize(2)
+        }
+        barnetrygdService.finnPersonerBarnetrygdPensjon("2023").also {
+            assertThat(it).hasSize(1)
+        }
+    }
+
     @Test
     fun `sjekk at antall personer med utvidet barnetrygd er riktig innenfor hvert av årene 2019, 2020 og 2021`() {
         val personFraInneværendeÅr = TestData.person()