Refaktorerer og fjernet klasse SamordningService

behandlingsflyt/src/main/kotlin/no/nav/aap/behandlingsflyt/behandling/avklaringsbehov/løser/AvklarSamordningGraderingLøser.kt

@@ -2,7 +2,7 @@ package no.nav.aap.behandlingsflyt.behandling.avklaringsbehov.løser
 
 import no.nav.aap.behandlingsflyt.behandling.avklaringsbehov.AvklaringsbehovKontekst
 import no.nav.aap.behandlingsflyt.behandling.avklaringsbehov.løsning.AvklarSamordningGraderingLøsning
-import no.nav.aap.behandlingsflyt.behandling.samordning.SamordningService
+import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.SamordningYtelseVurderingGrunnlag
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering.SamordningVurdering
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering.SamordningVurderingGrunnlag
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering.SamordningVurderingPeriode
@@ -29,8 +29,6 @@ class AvklarSamordningGraderingLøser(
         val vurderingerForSamordning = løsning.vurderingerForSamordning
             .also(VurderingerForSamordning::valider)
 
-        val samordningService = SamordningService(samordningYtelseVurderingRepository, samordningYtelseRepository)
-
         val samordningYtelseGrunnlag = samordningYtelseRepository.hentHvisEksisterer(kontekst.behandlingId())
         val samordningsvurderinger = SamordningVurderingGrunnlag(
             begrunnelse = vurderingerForSamordning.begrunnelse,
@@ -51,10 +49,13 @@ class AvklarSamordningGraderingLøser(
             vurdertTidspunkt = LocalDateTime.now()
         )
 
-        val perioderSomIkkeHarBlittVurdert = samordningService.perioderSomIkkeHarBlittVurdert(
-            samordningYtelseGrunnlag, samordningService.vurderingTidslinje(samordningsvurderinger)
+        val grunnlag = SamordningYtelseVurderingGrunnlag(
+            ytelseGrunnlag = samordningYtelseGrunnlag,
+            vurderingGrunnlag = samordningsvurderinger,
         )
 
+        val perioderSomIkkeHarBlittVurdert = grunnlag.perioderSomIkkeHarBlittVurdert()
+
         if (perioderSomIkkeHarBlittVurdert.isNotEmpty()) {
             throw UgyldigForespørselException(message = "Har ikke vurdert alle perioder for samordning med andre folketrygdytelser")
         }

behandlingsflyt/src/main/kotlin/no/nav/aap/behandlingsflyt/behandling/vilkår/samordning/annenfullytelse/SamordningAnnenFullYtelseVilkår.kt

@@ -1,6 +1,5 @@
 package no.nav.aap.behandlingsflyt.behandling.vilkår.samordning.annenfullytelse
 
-import no.nav.aap.behandlingsflyt.behandling.samordning.SamordningGradering
 import no.nav.aap.behandlingsflyt.behandling.vilkår.Vilkårsvurderer
 import no.nav.aap.behandlingsflyt.faktagrunnlag.Faktagrunnlag
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.SamordningYtelseVurderingGrunnlag
@@ -12,14 +11,12 @@ import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.vilkårsresultat.Vi
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.vilkårsresultat.Vilkårsvurdering
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.vilkårsresultat.Vilkårtype
 import no.nav.aap.behandlingsflyt.faktagrunnlag.register.uføre.UføreGrunnlag
-import no.nav.aap.komponenter.tidslinje.Tidslinje
 import no.nav.aap.komponenter.tidslinje.orEmpty
 import no.nav.aap.komponenter.type.Periode
 import no.nav.aap.komponenter.verdityper.Prosent.Companion.`100_PROSENT`
 
 data class SamordningAnnenFullYtelseFaktagrunnlag(
     val rettighetsperiode: Periode,
-    val samordningTidslinje: Tidslinje<SamordningGradering>,
     val samordningGrunnlag: SamordningYtelseVurderingGrunnlag?,
     val uføreRegisterGrunnlag: UføreGrunnlag?,
     val uføreVurderingGrunnlag: SamordningUføreGrunnlag?,
@@ -32,10 +29,11 @@ class SamordningAnnenFullYtelseVilkår(vilkårsresultat: Vilkårsresultat) :
 
     override fun vurder(grunnlag: SamordningAnnenFullYtelseFaktagrunnlag) {
         val uføreTidslinje = grunnlag.uføreVurderingGrunnlag?.vurdering?.tilTidslinje().orEmpty()
+        val samordningTidslinje = grunnlag.samordningGrunnlag?.tilTidslinje().orEmpty()
 
         /* NB: bevisst valg å ikke gi avslag selv om summen av samordninger blir til 100%. */
         val vurderinger =
-            grunnlag.samordningTidslinje.outerJoinNotNull(uføreTidslinje) { andreYtelserSamordning, samordningUføreGradering ->
+            samordningTidslinje.outerJoinNotNull(uføreTidslinje) { andreYtelserSamordning, samordningUføreGradering ->
                 val samordningerYtelser =
                     andreYtelserSamordning?.ytelsesGraderinger.orEmpty()
                         .map { it.ytelse.toString() to it.gradering }

behandlingsflyt/src/main/kotlin/no/nav/aap/behandlingsflyt/faktagrunnlag/delvurdering/samordning/SamordningGrunnlag.kt

@@ -1,15 +1,88 @@
 package no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning
 
+import no.nav.aap.behandlingsflyt.behandling.samordning.AvklaringsType
+import no.nav.aap.behandlingsflyt.behandling.samordning.SamordningGradering
+import no.nav.aap.behandlingsflyt.behandling.samordning.Ytelse
+import no.nav.aap.behandlingsflyt.behandling.samordning.YtelseGradering
 import no.nav.aap.behandlingsflyt.faktagrunnlag.Faktagrunnlag
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering.SamordningVurderingGrunnlag
 import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering.SamordningYtelseGrunnlag
+import no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering.SamordningYtelsePeriode
+import no.nav.aap.komponenter.tidslinje.JoinStyle
+import no.nav.aap.komponenter.tidslinje.Segment
+import no.nav.aap.komponenter.tidslinje.StandardSammenslåere
+import no.nav.aap.komponenter.tidslinje.StandardSammenslåere.slåSammenTilListe
+import no.nav.aap.komponenter.tidslinje.Tidslinje
+import no.nav.aap.komponenter.tidslinje.orEmpty
 import no.nav.aap.komponenter.type.Periode
 import no.nav.aap.komponenter.verdityper.Prosent
+import kotlin.math.min
 
 data class SamordningYtelseVurderingGrunnlag(
     val ytelseGrunnlag: SamordningYtelseGrunnlag?,
-    val vurderingGrunnlag: SamordningVurderingGrunnlag?
-) : Faktagrunnlag
+    val vurderingGrunnlag: SamordningVurderingGrunnlag?,
+): Faktagrunnlag {
+    fun tilTidslinje(): Tidslinje<SamordningGradering> {
+        val manuelleVurderinger = vurderingGrunnlag?.tilTidslinje().orEmpty()
+
+        /**
+         * Henter kun automatiske ytelser fra register - disse skal ikke ha overlappende perioder
+         * Pr nå har vi ingen typer som er satt opp til å vurderes automatisk
+         */
+        val hentedeYtelserFraRegisterForAutomatiskVurdering =
+            ytelseGrunnlag?.ytelser.orEmpty()
+                .filter { it.ytelseType.type == AvklaringsType.AUTOMATISK }
+                .map { ytelse ->
+                    Tidslinje(ytelse.ytelsePerioder.map { Segment(it.periode, Pair(ytelse.ytelseType, it)) })
+                }.fold(Tidslinje.empty<List<Pair<Ytelse, SamordningYtelsePeriode>>>()) { acc, curr ->
+                    acc.kombiner(curr, slåSammenTilListe())
+                }
+
+        // Slå sammen med vurderinger og regn ut graderinger
+        return hentedeYtelserFraRegisterForAutomatiskVurdering.kombiner(
+            manuelleVurderinger,
+            JoinStyle.OUTER_JOIN { periode, venstre, høyre ->
+                // Manuelt vurderte perioder er allerede validert
+                val manueltVurderteGraderinger =
+                    høyre?.verdi.orEmpty().associate { it.first to it.second }
+                        .mapValues { it.value.gradering!! }
+                        .filterKeys { it.type == AvklaringsType.MANUELL }
+
+                val registerVurderinger =
+                    venstre?.verdi.orEmpty().associate { it.first to it.second.gradering!! }
+                        .filterKeys { it.type == AvklaringsType.AUTOMATISK }
+
+                val alleSammen = manueltVurderteGraderinger.plus(registerVurderinger)
+                val gradering = min(alleSammen.values.sumOf { it.prosentverdi() }, 100)
+                Segment(
+                    periode, SamordningGradering(
+                        gradering = Prosent(gradering),
+                        ytelsesGraderinger = alleSammen.entries.map { YtelseGradering(it.key, it.value) }
+                    )
+                )
+            }
+        )
+    }
+
+    fun perioderSomIkkeHarBlittVurdert(): Tidslinje<List<Ytelse>> {
+        val ytelseTidslinje = tidslinjeMedSamordningYtelser()
+        val vurderingTidslinje = vurderingGrunnlag?.tilTidslinje().orEmpty()
+        return ytelseTidslinje.kombiner(vurderingTidslinje, StandardSammenslåere.minus())
+    }
+
+    fun tidslinjeMedSamordningYtelser(): Tidslinje<List<Ytelse>> {
+        return ytelseGrunnlag?.ytelser.orEmpty()
+            .filter { it.ytelseType.type == AvklaringsType.MANUELL }
+            .map { ytelse ->
+                val tidslinjePerPeriode = ytelse.ytelsePerioder.map { Tidslinje(it.periode, ytelse.ytelseType) }
+                tidslinjePerPeriode.fold(Tidslinje.empty<Ytelse>()) { acc, curr ->
+                    acc.kombiner(curr, StandardSammenslåere.prioriterHøyreSideCrossJoin())
+                }.komprimer()
+            }.fold(Tidslinje.empty()) { acc, curr ->
+                acc.kombiner(curr, slåSammenTilListe())
+            }
+    }
+}
 
 /**
  * Grunnlag fra samordningssteget som brukes i følgende steg.

behandlingsflyt/src/main/kotlin/no/nav/aap/behandlingsflyt/faktagrunnlag/delvurdering/samordning/ytelsevurdering/SamordningYtelseVurderingModell.kt

@@ -1,6 +1,10 @@
 package no.nav.aap.behandlingsflyt.faktagrunnlag.delvurdering.samordning.ytelsevurdering
 
+import no.nav.aap.behandlingsflyt.behandling.samordning.AvklaringsType
 import no.nav.aap.behandlingsflyt.behandling.samordning.Ytelse
+import no.nav.aap.komponenter.tidslinje.Segment
+import no.nav.aap.komponenter.tidslinje.StandardSammenslåere.slåSammenTilListe
+import no.nav.aap.komponenter.tidslinje.Tidslinje
 import no.nav.aap.komponenter.type.Periode
 import no.nav.aap.komponenter.verdityper.Prosent
 import java.time.LocalDateTime
@@ -41,7 +45,18 @@ data class SamordningVurderingGrunnlag(
     val vurderinger: Set<SamordningVurdering>,
     val vurdertAv: String,
     val vurdertTidspunkt: LocalDateTime
-)
+) {
+    fun tilTidslinje(): Tidslinje<List<Pair<Ytelse, SamordningVurderingPeriode>>> {
+        return vurderinger.filter { it.ytelseType.type == AvklaringsType.MANUELL }
+            .map { ytelse ->
+                val segmenterForYtelse =
+                    ytelse.vurderingPerioder.map { Segment(it.periode, Pair(ytelse.ytelseType, it)) }
+                Tidslinje(segmenterForYtelse)
+            }.fold(Tidslinje.empty()) { acc, curr ->
+                acc.kombiner(curr, slåSammenTilListe())
+            }
+    }
+}
 
 interface SamordningPeriode {
     val periode: Periode