Ta i bruk tidslinje fra familie-felles i VilkårsvurderingTidslinjer

src/main/kotlin/no/nav/familie/ba/sak/kjerne/behandling/behandlingstema/BehandlingstemaService.kt

@@ -12,13 +12,12 @@ import no.nav.familie.ba.sak.kjerne.beregning.domene.AndelTilkjentYtelseReposito
 import no.nav.familie.ba.sak.kjerne.eøs.felles.BehandlingId
 import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingTidslinjeService
 import no.nav.familie.ba.sak.kjerne.logg.LoggService
-import no.nav.familie.ba.sak.kjerne.tidslinje.komposisjon.innholdForTidspunkt
-import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.MånedTidspunkt.Companion.tilTidspunkt
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.komposisjon.verdiPåTidspunkt
 import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Regelverk
 import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Vilkår
 import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.VilkårsvurderingRepository
 import org.springframework.stereotype.Service
-import java.time.YearMonth
+import java.time.LocalDate
 
 @Service
 class BehandlingstemaService(
@@ -87,14 +86,14 @@ class BehandlingstemaService(
             tidslinjer
                 .barnasTidslinjer()
                 .values
-                .map { it.egetRegelverkResultatTidslinje.innholdForTidspunkt(YearMonth.now(clockProvider.get()).tilTidspunkt()) }
+                .map { it.egetRegelverkResultatTidslinje.verdiPåTidspunkt(LocalDate.now(clockProvider.get())) }
 
-        val etBarnHarMinstEnLøpendeEØSPeriode = alleBarnasTidslinjerSomHarLøpendePeriode.any { it.innhold?.regelverk == Regelverk.EØS_FORORDNINGEN }
+        val etBarnHarMinstEnLøpendeEØSPeriode = alleBarnasTidslinjerSomHarLøpendePeriode.any { it?.regelverk == Regelverk.EØS_FORORDNINGEN }
         if (etBarnHarMinstEnLøpendeEØSPeriode) {
             return BehandlingKategori.EØS
         }
 
-        val etBarnHarMinstEnLøpendeNasjonalPeriode = alleBarnasTidslinjerSomHarLøpendePeriode.any { it.innhold?.regelverk == Regelverk.NASJONALE_REGLER }
+        val etBarnHarMinstEnLøpendeNasjonalPeriode = alleBarnasTidslinjerSomHarLøpendePeriode.any { it?.regelverk == Regelverk.NASJONALE_REGLER }
         if (etBarnHarMinstEnLøpendeNasjonalPeriode) {
             return BehandlingKategori.NASJONAL
         }

src/main/kotlin/no/nav/familie/ba/sak/kjerne/eøs/vilkårsvurdering/VilkårsresultatDagTidslinje.kt

@@ -6,6 +6,8 @@ import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Dag
 import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.DagTidspunkt.Companion.tilTidspunktEllerUendeligSent
 import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.DagTidspunkt.Companion.tilTidspunktEllerUendeligTidlig
 import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.VilkårResultat
+import no.nav.familie.tidslinje.tilTidslinje
+import no.nav.familie.tidslinje.Periode as FamilieFellesPeriode
 
 /**
  * Lager tidslinje av VilkårRegelverkResultat for ett vilkår og én aktør
@@ -36,3 +38,21 @@ fun VilkårResultat.tilPeriode(): Periode<VilkårRegelverkResultat, Dag> {
         ),
     )
 }
+
+fun Iterable<VilkårResultat>.tilVilkårRegelverkResultatTidslinjeFamilieFelles() =
+    this
+        .filter { it.erOppfylt() }
+        .map { it.tilPeriodeNy() }
+        .tilTidslinje()
+
+private fun VilkårResultat.tilPeriodeNy(): FamilieFellesPeriode<VilkårRegelverkResultat> =
+    FamilieFellesPeriode(
+        verdi =
+            VilkårRegelverkResultat(
+                vilkår = vilkårType,
+                regelverkResultat = this.tilRegelverkResultat(),
+                utdypendeVilkårsvurderinger = this.utdypendeVilkårsvurderinger,
+            ),
+        fom = periodeFom,
+        tom = periodeTom,
+    )

src/main/kotlin/no/nav/familie/ba/sak/kjerne/eøs/vilkårsvurdering/VilkårsresultatMånedTidslinje.kt

@@ -3,6 +3,8 @@ package no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering
 import no.nav.familie.ba.sak.kjerne.tidslinje.Tidslinje
 import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Dag
 import no.nav.familie.ba.sak.kjerne.tidslinje.transformasjon.tilMånedFraMånedsskifteIkkeNull
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.transformasjon.tilMånedFraMånedsskifteIkkeNull
+import no.nav.familie.tidslinje.Tidslinje as FamilieFellesTidslinje
 
 /**
  * Extension-funksjon som konverterer en dag-basert tidslinje til en måned-basert tidslinje med VilkårRegelverkResultat
@@ -24,3 +26,9 @@ fun Tidslinje<VilkårRegelverkResultat, Dag>.tilMånedsbasertTidslinjeForVilkår
         .tilMånedFraMånedsskifteIkkeNull { sisteDagForrigeMåned, førsteDagDenneMåned ->
             if (sisteDagForrigeMåned.erOppfylt() && førsteDagDenneMåned.erOppfylt()) førsteDagDenneMåned else null
         }
+
+fun FamilieFellesTidslinje<VilkårRegelverkResultat>.tilMånedsbasertTidslinjeForVilkårRegelverkResultat() =
+    this
+        .tilMånedFraMånedsskifteIkkeNull { sisteDagForrigeMåned, førsteDagDenneMåned ->
+            if (sisteDagForrigeMåned.erOppfylt() && førsteDagDenneMåned.erOppfylt()) førsteDagDenneMåned else null
+        }

src/main/kotlin/no/nav/familie/ba/sak/kjerne/eøs/vilkårsvurdering/VilkårsvurderingTidslinjeService.kt

@@ -28,9 +28,20 @@ class VilkårsvurderingTidslinjeService(
         )
     }
 
-    fun hentTidslinjer(behandlingId: BehandlingId): VilkårsvurderingTidslinjer? {
+    // TODO: Endre navn til hentTidslinjerThrows når den andre funksjonen er slettet
+    fun hentFamilieFellesTidslinjerThrows(behandlingId: BehandlingId): VilkårsvurderingFamilieFellesTidslinjer {
+        val vilkårsvurdering = vilkårsvurderingRepository.findByBehandlingAndAktiv(behandlingId = behandlingId.id)!!
+        val søkerOgBarn = persongrunnlagService.hentSøkerOgBarnPåBehandlingThrows(behandlingId = behandlingId.id)
+
+        return VilkårsvurderingFamilieFellesTidslinjer(
+            vilkårsvurdering = vilkårsvurdering,
+            søkerOgBarn = søkerOgBarn,
+        )
+    }
+
+    fun hentTidslinjer(behandlingId: BehandlingId): VilkårsvurderingFamilieFellesTidslinjer? {
         return try {
-            hentTidslinjerThrows(behandlingId)
+            hentFamilieFellesTidslinjerThrows(behandlingId)
         } catch (exception: NullPointerException) {
             return null
         }

src/main/kotlin/no/nav/familie/ba/sak/kjerne/eøs/vilkårsvurdering/VilkårsvurderingTidslinjer.kt

@@ -15,9 +15,15 @@ import no.nav.familie.ba.sak.kjerne.tidslinje.komposisjon.kombinerMed
 import no.nav.familie.ba.sak.kjerne.tidslinje.komposisjon.kombinerUtenNull
 import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Dag
 import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Måned
-import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Tidsenhet
 import no.nav.familie.ba.sak.kjerne.tidslinje.transformasjon.beskjærEtter
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.komposisjon.kombinerUtenNull
+import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.VilkårResultat
 import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Vilkårsvurdering
+import no.nav.familie.tidslinje.beskjærEtter
+import no.nav.familie.tidslinje.inneholder
+import no.nav.familie.tidslinje.utvidelser.kombinerMed
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.komposisjon.erUnder18ÅrVilkårTidslinje as familieFellesErUnder18ÅrVilkårTidslinje
+import no.nav.familie.tidslinje.Tidslinje as FamilieFellesTidslinje
 
 class VilkårsvurderingTidslinjer(
     vilkårsvurdering: Vilkårsvurdering,
@@ -128,17 +134,106 @@ class VilkårsvurderingTidslinjer(
     }
 }
 
-fun VilkårsvurderingTidslinjer.harBlandetRegelverk(): Boolean =
-    this.søkerHarNasjonalOgFinnesBarnMedEøs() ||
-        søkersTidslinjer().regelverkResultatTidslinje.inneholder(RegelverkResultat.OPPFYLT_BLANDET_REGELVERK) ||
-        barnasTidslinjer().values.any { it.egetRegelverkResultatTidslinje.inneholder(RegelverkResultat.OPPFYLT_BLANDET_REGELVERK) }
-
-private fun VilkårsvurderingTidslinjer.søkerHarNasjonalOgFinnesBarnMedEøs(): Boolean =
-    barnasTidslinjer().values.any {
-        it.egetRegelverkResultatTidslinje
-            .kombinerMed(søkersTidslinjer().regelverkResultatTidslinje) { barnRegelverk, søkerRegelverk ->
-                barnRegelverk == RegelverkResultat.OPPFYLT_EØS_FORORDNINGEN && søkerRegelverk == RegelverkResultat.OPPFYLT_NASJONALE_REGLER
-            }.inneholder(true)
+// TODO: Endre navn til VilkårsvurderingTidslinjer når den andre klassen er slettet
+class VilkårsvurderingFamilieFellesTidslinjer(
+    vilkårsvurdering: Vilkårsvurdering,
+    søkerOgBarn: List<PersonEnkel>,
+) {
+    private val barna: List<PersonEnkel> = søkerOgBarn.barn()
+    private val søker: Aktør = søkerOgBarn.søker().aktør
+
+    private val søkersTidslinje: SøkersTidslinjer =
+        SøkersTidslinjer(
+            vilkårResultater = vilkårsvurdering.hentPersonResultaterTil(søker.aktørId),
+            fagsakType = vilkårsvurdering.behandling.fagsak.type,
+            behandlingUnderkategori = vilkårsvurdering.behandling.underkategori,
+        )
+
+    private val barnasTidslinjer: Map<Aktør, BarnetsTidslinjer> =
+        barna.associate {
+            it.aktør to
+                BarnetsTidslinjer(
+                    barn = it,
+                    vilkårResultater = vilkårsvurdering.hentPersonResultaterTil(it.aktør.aktørId),
+                    søkersRegelverkResultatTidslinje = søkersTidslinje.regelverkResultatTidslinje,
+                    fagsakType = vilkårsvurdering.behandling.fagsak.type,
+                    behandlingUnderkategori = vilkårsvurdering.behandling.underkategori,
+                )
+        }
+
+    fun søkersTidslinje(): SøkersTidslinjer = søkersTidslinje
+
+    fun barnasTidslinjer(): Map<Aktør, BarnetsTidslinjer> = barnasTidslinjer
+
+    class SøkersTidslinjer(
+        vilkårResultater: List<VilkårResultat>,
+        fagsakType: FagsakType,
+        behandlingUnderkategori: BehandlingUnderkategori,
+    ) {
+        val vilkårsresultatTidslinjer =
+            vilkårResultater
+                .groupBy { it.vilkårType }
+                .map { it.value.tilVilkårRegelverkResultatTidslinjeFamilieFelles() }
+
+        val regelverkResultatTidslinje =
+            vilkårsresultatTidslinjer
+                .map { it.tilMånedsbasertTidslinjeForVilkårRegelverkResultat() }
+                .kombinerUtenNull {
+                    kombinerVilkårResultaterTilRegelverkResultat(
+                        personType = PersonType.SØKER,
+                        alleVilkårResultater = it,
+                        fagsakType = fagsakType,
+                        behandlingUnderkategori = behandlingUnderkategori,
+                    )
+                }
+    }
+
+    class BarnetsTidslinjer(
+        barn: PersonEnkel,
+        vilkårResultater: List<VilkårResultat>,
+        søkersRegelverkResultatTidslinje: FamilieFellesTidslinje<RegelverkResultat>,
+        fagsakType: FagsakType,
+        behandlingUnderkategori: BehandlingUnderkategori,
+    ) {
+        val erUnder18ÅrVilkårTidslinje = familieFellesErUnder18ÅrVilkårTidslinje(barn.fødselsdato)
+
+        val vilkårsresultatTidslinjer =
+            vilkårResultater
+                .groupBy { it.vilkårType }
+                .map { it.value.tilVilkårRegelverkResultatTidslinjeFamilieFelles() }
+
+        val egetRegelverkResultatTidslinje: FamilieFellesTidslinje<RegelverkResultat> =
+            vilkårsresultatTidslinjer
+                .map { it.tilMånedsbasertTidslinjeForVilkårRegelverkResultat() }
+                .kombinerUtenNull {
+                    kombinerVilkårResultaterTilRegelverkResultat(
+                        personType = PersonType.BARN,
+                        alleVilkårResultater = it,
+                        fagsakType = fagsakType,
+                        behandlingUnderkategori = behandlingUnderkategori,
+                    )
+                }.beskjærEtter(erUnder18ÅrVilkårTidslinje)
+
+        val regelverkResultatTidslinje =
+            egetRegelverkResultatTidslinje
+                .kombinerMed(søkersRegelverkResultatTidslinje) { barnetsResultat, søkersResultat ->
+                    barnetsResultat.kombinerMed(søkersResultat)
+                }
+                // Barnets egne tidslinjer kan på dette tidspunktet strekke seg 18 år frem i tid,
+                // og mye lenger enn søkers regelverk-tidslinje, som skal være begrensningen. Derfor beskjærer vi mot den
+                .beskjærEtter(søkersRegelverkResultatTidslinje)
     }
 
-fun <I, T : Tidsenhet> Tidslinje<I, T>.inneholder(innhold: I): Boolean = this.perioder().any { it.innhold == innhold }
+    fun harBlandetRegelverk(): Boolean =
+        søkerHarNasjonalOgFinnesBarnMedEøs() ||
+            søkersTidslinje().regelverkResultatTidslinje.inneholder(RegelverkResultat.OPPFYLT_BLANDET_REGELVERK) ||
+            barnasTidslinjer().values.any { it.egetRegelverkResultatTidslinje.inneholder(RegelverkResultat.OPPFYLT_BLANDET_REGELVERK) }
+
+    private fun søkerHarNasjonalOgFinnesBarnMedEøs(): Boolean =
+        barnasTidslinjer().values.any {
+            it.egetRegelverkResultatTidslinje
+                .kombinerMed(søkersTidslinje().regelverkResultatTidslinje) { barnRegelverk, søkerRegelverk ->
+                    barnRegelverk == RegelverkResultat.OPPFYLT_EØS_FORORDNINGEN && søkerRegelverk == RegelverkResultat.OPPFYLT_NASJONALE_REGLER
+                }.inneholder(true)
+        }
+}

src/main/kotlin/no/nav/familie/ba/sak/kjerne/eøs/vilkårsvurdering/rest/RestTidslinjer.kt

@@ -1,27 +1,27 @@
 package no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.rest
 
+import no.nav.familie.ba.sak.common.førsteDagIInneværendeMåned
+import no.nav.familie.ba.sak.common.sisteDagIMåned
 import no.nav.familie.ba.sak.kjerne.autovedtak.fødselshendelse.Resultat
 import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårRegelverkResultat
-import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingTidslinjer
-import no.nav.familie.ba.sak.kjerne.tidslinje.Tidslinje
-import no.nav.familie.ba.sak.kjerne.tidslinje.eksperimentelt.filtrerIkkeNull
-import no.nav.familie.ba.sak.kjerne.tidslinje.komposisjon.kombinerUtenNull
-import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Måned
-import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.Tidsenhet
-import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.tilFørsteDagIMåneden
-import no.nav.familie.ba.sak.kjerne.tidslinje.tidspunkt.tilSisteDagIMåneden
-import no.nav.familie.ba.sak.kjerne.tidslinje.transformasjon.beskjærEtter
-import no.nav.familie.ba.sak.kjerne.tidslinje.transformasjon.beskjærTilOgMedEtter
-import no.nav.familie.ba.sak.kjerne.tidslinje.transformasjon.map
-import no.nav.familie.ba.sak.kjerne.tidslinje.transformasjon.tilDag
+import no.nav.familie.ba.sak.kjerne.eøs.vilkårsvurdering.VilkårsvurderingFamilieFellesTidslinjer
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.komposisjon.kombinerUtenNull
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.komposisjon.mapVerdiNullable
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.transformasjon.beskjærTilOgMedEtter
+import no.nav.familie.ba.sak.kjerne.tidslinjefamiliefelles.transformasjon.tilDag
 import no.nav.familie.ba.sak.kjerne.vilkårsvurdering.domene.Regelverk
+import no.nav.familie.tidslinje.PRAKTISK_TIDLIGSTE_DAG
+import no.nav.familie.tidslinje.Tidslinje
+import no.nav.familie.tidslinje.beskjærEtter
+import no.nav.familie.tidslinje.filtrerIkkeNull
+import no.nav.familie.tidslinje.utvidelser.tilPerioder
 import java.time.LocalDate
 
-fun VilkårsvurderingTidslinjer.tilRestTidslinjer(): RestTidslinjer {
+fun VilkårsvurderingFamilieFellesTidslinjer.tilRestTidslinjer(): RestTidslinjer {
     val barnasTidslinjer = this.barnasTidslinjer()
-    val søkersTidslinjer = this.søkersTidslinjer()
+    val søkersTidslinje = this.søkersTidslinje()
 
-    val erNoenAvBarnaMellom0Og18ÅrTidslinje: Tidslinje<Boolean, Måned> =
+    val erNoenAvBarnaMellom0Og18ÅrTidslinje: Tidslinje<Boolean> =
         barnasTidslinjer.values
             .map { it.erUnder18ÅrVilkårTidslinje }
             .kombinerUtenNull { barnaEr0Til18ÅrListe -> barnaEr0Til18ÅrListe.any { it } }
@@ -41,40 +41,40 @@ fun VilkårsvurderingTidslinjer.tilRestTidslinjer(): RestTidslinjer {
                         oppfyllerEgneVilkårIKombinasjonMedSøkerTidslinje =
                             it.value
                                 .regelverkResultatTidslinje
-                                .map { it?.resultat }
+                                .mapVerdiNullable { it?.resultat }
                                 .beskjærEtter(erUnder18årTidslinje)
                                 .tilRestTidslinje(),
                         regelverkTidslinje =
                             it.value.regelverkResultatTidslinje
-                                .map { it?.regelverk }
+                                .mapVerdiNullable { it?.regelverk }
                                 .beskjærEtter(erUnder18årTidslinje)
                                 .tilRestTidslinje(),
                     )
             },
         søkersTidslinjer =
             RestTidslinjerForSøker(
                 vilkårTidslinjer =
-                    søkersTidslinjer.vilkårsresultatTidslinjer.map {
+                    søkersTidslinje.vilkårsresultatTidslinjer.map {
                         it
                             .beskjærTilOgMedEtter(erNoenAvBarnaMellom0Og18ÅrTidslinje.tilDag())
                             .tilRestTidslinje()
                     },
                 oppfyllerEgneVilkårTidslinje =
-                    søkersTidslinjer
+                    søkersTidslinje
                         .regelverkResultatTidslinje
-                        .map { it?.resultat }
+                        .mapVerdiNullable { it?.resultat }
                         .beskjærTilOgMedEtter(erNoenAvBarnaMellom0Og18ÅrTidslinje)
                         .tilRestTidslinje(),
             ),
     )
 }
 
-fun <I, T : Tidsenhet> Tidslinje<I, T>.tilRestTidslinje(): List<RestTidslinjePeriode<I>> =
-    this.filtrerIkkeNull().perioder().map { periode ->
+fun <V> Tidslinje<V>.tilRestTidslinje(): List<RestTidslinjePeriode<V>> =
+    this.tilPerioder().filtrerIkkeNull().map { periode ->
         RestTidslinjePeriode(
-            fraOgMed = periode.fraOgMed.tilFørsteDagIMåneden().tilLocalDate(),
-            tilOgMed = periode.tilOgMed.tilSisteDagIMåneden().tilLocalDate(),
-            innhold = periode.innhold!!,
+            fraOgMed = periode.fom?.førsteDagIInneværendeMåned() ?: PRAKTISK_TIDLIGSTE_DAG,
+            tilOgMed = periode.tom?.sisteDagIMåned(),
+            innhold = periode.verdi,
         )
     }
 

src/main/kotlin/no/nav/familie/ba/sak/kjerne/eøs/vilkårsvurdering/rest/TidslinjeController.kt

@@ -34,7 +34,7 @@ class TidslinjeController(
         )
         return ResponseEntity.ok(
             success(
-                tidslinjeService.hentTidslinjerThrows(BehandlingId(behandlingId)).tilRestTidslinjer(),
+                tidslinjeService.hentFamilieFellesTidslinjerThrows(BehandlingId(behandlingId)).tilRestTidslinjer(),
             ),
         )
     }

src/main/kotlin/no/nav/familie/ba/sak/kjerne/tidslinjefamiliefelles/komposisjon/TidslinjeKombinator.kt

@@ -141,3 +141,14 @@ fun <V, R> Collection<Tidslinje<V>>.kombinerNullableKombinator(listeKombinator:
             is Udefinert -> Udefinert()
         }
     }
+
+fun <V, R> Tidslinje<V>.mapVerdiNullable(mapper: (V?) -> R?): Tidslinje<R> =
+    this.map { periodeVerdi ->
+        when (periodeVerdi) {
+            is Verdi,
+            is Null,
+            -> mapper(periodeVerdi.verdi)?.let { Verdi(it) } ?: Null()
+
+            is Udefinert -> Udefinert()
+        }
+    }