Add utfall manuell to behandling

src/main/kotlin/no/nav/pensjon/opptjening/omsorgsopptjening/bestem/pensjonsopptjening/omsorgsopptjening/model/Behandling.kt

@@ -13,6 +13,7 @@ data class Behandling(
     private val vurderVilkår: VurderVilkår,
     private val meldingId: UUID
 ) {
+    val vilkarsVurdering = vilkårsvurdering()
     fun omsorgsår() = grunnlag.omsorgsAr
     fun omsorgsmottaker() = grunnlag.omsorgsmottaker
     fun omsorgsyter() = grunnlag.omsorgsyter
@@ -22,14 +23,25 @@ data class Behandling(
     fun meldingId() = meldingId
 
     fun utfall(): BehandlingUtfall {
-        return vilkårsvurdering().let { vilkårsvurdering ->
+        return vilkarsVurdering.let { vilkårsvurdering ->
             when (vilkårsvurdering.utfall.erInnvilget()) {
                 true -> BehandlingUtfall.Innvilget
-                false -> BehandlingUtfall.Avslag
+                false -> {
+                    if (behovForManuellBehandling()) {
+                        BehandlingUtfall.Manuell
+                    } else {
+                        BehandlingUtfall.Avslag
+                    }
+                }
             }
         }
     }
 
+    fun behovForManuellBehandling(): Boolean {
+        //TODO utvide med andre feilsituasjoner som må sjekkes manuelt?
+        return vilkarsVurdering.behovForManuellBehandling()
+    }
+
 
     fun vilkårsvurdering(): VilkarsVurdering<*> {
         return og(
@@ -53,7 +65,11 @@ data class Behandling(
     private fun vilkårsurderHjelpestønad(): VilkarsVurdering<*> {
         return og(
             vurderVilkår.OmsorgsmottakerOppfyllerAlderskravForHjelpestønad(),
-            //vurderVilkår.OmsorgsyterErForelderTilMottakerAvHjelpestønad(), dette var ikke et kriterium i batch
+            /**
+             * @see FullførtBehandling.sendBrev
+             * Ikke et kriterium i bpen030
+             */
+            //vurderVilkår.OmsorgsyterErForelderTilMottakerAvHjelpestønad()
         )
     }
 

src/main/kotlin/no/nav/pensjon/opptjening/omsorgsopptjening/bestem/pensjonsopptjening/omsorgsopptjening/model/FullførtBehandling.kt

@@ -4,8 +4,6 @@ import no.nav.pensjon.opptjening.omsorgsopptjening.bestem.pensjonsopptjening.bre
 import no.nav.pensjon.opptjening.omsorgsopptjening.bestem.pensjonsopptjening.godskriv.model.GodskrivOpptjening
 import no.nav.pensjon.opptjening.omsorgsopptjening.bestem.pensjonsopptjening.persongrunnlag.model.DomainOmsorgstype
 import no.nav.pensjon.opptjening.omsorgsopptjening.bestem.pensjonsopptjening.persongrunnlag.model.Pensjonspoeng
-import no.nav.pensjon.opptjening.omsorgsopptjening.bestem.pensjonsopptjening.oppgave.model.Oppgave
-import no.nav.pensjon.opptjening.omsorgsopptjening.bestem.pensjonsopptjening.oppgave.model.OppgaveDetaljer
 import java.time.Instant
 import java.util.UUID
 
@@ -34,87 +32,11 @@ data class FullførtBehandling(
         return GodskrivOpptjening.Transient(behandlingId = id)
     }
 
-    fun opprettOppgave(
-        oppgaveEksistererForOmsorgsyter: (omsorgsyter: String, år: Int) -> Boolean,
-        oppgaveEksistererForOmsorgsmottaker: (omsorgsmottaker: String, år: Int) -> Boolean,
-    ): Oppgave.Transient? {
-        require(!erInnvilget()) { "Kan kun opprette oppgave for avslått behandling!" }
-        return avslagSkyldesFlereOmsorgsytereMedLikeMangeOmsorgsmåneder()?.let { vurdering ->
-            VelgOppgaveForPersonOgInnhold(grunnlag = vurdering.grunnlag).let { oppgaveOgInnhold ->
-                val oppgaveGjelderOmsorgsyter = oppgaveOgInnhold.oppgaveForPerson() == omsorgsyter
-                val omsorgsyterHarOppgaveForÅr = oppgaveEksistererForOmsorgsyter(omsorgsyter, omsorgsAr)
-                val omsorgsMottakerHarOppgaveForÅr = oppgaveEksistererForOmsorgsmottaker(omsorgsmottaker, omsorgsAr)
-
-                if (oppgaveGjelderOmsorgsyter && !omsorgsyterHarOppgaveForÅr && !omsorgsMottakerHarOppgaveForÅr) {
-                    lagOppgave(mottakere = oppgaveOgInnhold)
-                } else {
-                    null
-                }
-            }
-        }
-    }
-
-    private fun lagOppgave(mottakere: VelgOppgaveForPersonOgInnhold): Oppgave.Transient {
-        return when (grunnlag) {
-            is OmsorgsopptjeningGrunnlag.FødtIOmsorgsår -> {
-                OppgaveDetaljer.FlereOmsorgytereMedLikeMyeOmsorgIFødselsår(
-                    omsorgsyter = omsorgsyter,
-                    omsorgsmottaker = omsorgsmottaker,
-                )
-            }
-
-            is OmsorgsopptjeningGrunnlag.IkkeFødtIOmsorgsår -> {
-                OppgaveDetaljer.FlereOmsorgytereMedLikeMyeOmsorg(
-                    omsorgsyter = omsorgsyter,
-                    omsorgsmottaker = omsorgsmottaker,
-                    annenOmsorgsyter = mottakere.annenPersonForInnhold(),
-                )
-            }
-        }.let {
-            Oppgave.Transient(
-                detaljer = it,
-                behandlingId = id,
-                meldingId = meldingId,
-            )
-        }
-    }
-
-    /**
-     * Det er bare aktuelt å lage oppgave i tilfeller hvor det ikke kan godskrives oppgjening som følge av at flere
-     * omsorgsyter har like mange omsorgsmåneder for det samme barnet i løpet av omsorgsåret.
-     */
-    private fun avslagSkyldesFlereOmsorgsytereMedLikeMangeOmsorgsmåneder(): OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering? {
-        return vilkårsvurdering.finnVurdering<OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering>().let {
-            if (vilkårsvurdering.erEnesteAvslag<OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering>() && it.grunnlag.omsorgsyterErEnAvFlereMedFlestOmsorgsmåneder()) {
-                it
-            } else {
-                null
-            }
-        }
-    }
-
-    /**
-     * Prioriterer oppgavemottakere etter kriteriene:
-     * 1. Flest omsorgsmåneder
-     * 2. Hadde omsorg i desember måned
-     * 3. Er personen [grunnlag] gjelder for
-     *    Dette sørger for at vi alltid prioriterer å sende oppgave for omsorgsyteren behandlingen gjelder.
-     */
-    private data class VelgOppgaveForPersonOgInnhold(
-        private val grunnlag: OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Grunnlag,
-    ) {
-        private val prioritert: List<OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.OmsorgsmånederForMottakerOgÅr> =
-            grunnlag
-                .omsorgsytereMedFlestOmsorgsmåneder()
-                .sortedWith(compareBy<OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.OmsorgsmånederForMottakerOgÅr> { it.haddeOmsorgIDesember() }.thenBy { it.omsorgsyter == grunnlag.omsorgsyter })
-                .reversed()
-
-        fun oppgaveForPerson(): String {
-            return prioritert.first().omsorgsyter
-        }
-
-        fun annenPersonForInnhold(): String {
-            return prioritert.first { it.omsorgsyter != grunnlag.omsorgsyter }.omsorgsyter
+    fun omsorgsmottakerFødtIOmsorgsår(): Boolean {
+        return when(this.grunnlag){
+            is OmsorgsopptjeningGrunnlag.FødtIOmsorgsår.FødtDesember -> true
+            is OmsorgsopptjeningGrunnlag.FødtIOmsorgsår.IkkeFødtDesember -> true
+            is OmsorgsopptjeningGrunnlag.IkkeFødtIOmsorgsår -> false
         }
     }
 
@@ -167,7 +89,7 @@ data class FullførtBehandling(
                 }
 
                 return if (
-                    !grunnlag.omsorgsyter.erForelderAv(omsorgsmottaker) || //TODO dette henger ikke sammen med vilkårsvurderingen atm
+                    !grunnlag.omsorgsyter.erForelderAv(omsorgsmottaker) ||
                     omsorgsytersOmsorgspoengForegåendeÅr.poeng == 0.0 ||
                     omsorgsytersOmsorgspoengForOmsorgsår > annenForeldersInntektspoengOmsorgsår
                 ) {
@@ -178,4 +100,9 @@ data class FullførtBehandling(
             }
         }
     }
+
+    fun hentOppgaveopplysninger(): Oppgaveopplysning {
+        require(utfall is BehandlingUtfall.Manuell) { "Kan kun opprette oppgave for manuell behandling" }
+        return vilkårsvurdering.hentVilkårSomMåbehandlesManuelt()?.hentOppgaveopplysninger() ?: throw RuntimeException("Behandlingsutfall er manuell, men fant ingen vilkår som krever manuell behandling")
+    }
 }

src/main/kotlin/no/nav/pensjon/opptjening/omsorgsopptjening/bestem/pensjonsopptjening/omsorgsopptjening/model/OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.kt

@@ -27,7 +27,55 @@ object OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere :
     data class Vurdering(
         override val grunnlag: Grunnlag,
         override val utfall: VilkårsvurderingUtfall
-    ) : ParagrafVurdering<Grunnlag>()
+    ) : ParagrafVurdering<Grunnlag>() {
+        fun hentOppgaveopplysninger(): Oppgaveopplysning {
+            return VelgOppgaveForPersonOgInnhold(grunnlag).let {
+                if (it.oppgaveForPerson() == grunnlag.omsorgsyter) {
+                    Oppgaveopplysning.ToOmsorgsytereMedLikeMangeMånederOmsorg(
+                        oppgaveMottaker = it.oppgaveForPerson(),
+                        annenOmsorgsyter = it.annenPersonForInnhold(),
+                        omsorgsmottaker = it.omsorgsmottaker(),
+                        omsorgsår = it.omsorgsår(),
+                    )
+                } else {
+                    Oppgaveopplysning.Ingen
+                }
+            }
+        }
+
+        /**
+         * Prioriterer oppgavemottakere etter kriteriene:
+         * 1. Flest omsorgsmåneder
+         * 2. Hadde omsorg i desember måned
+         * 3. Er personen [grunnlag] gjelder for
+         *    Dette sørger for at vi alltid prioriterer å sende oppgave for omsorgsyteren behandlingen gjelder.
+         */
+        private data class VelgOppgaveForPersonOgInnhold(
+            private val grunnlag: Grunnlag,
+        ) {
+            private val prioritert: List<OmsorgsmånederForMottakerOgÅr> =
+                grunnlag
+                    .omsorgsytereMedFlestOmsorgsmåneder()
+                    .sortedWith(compareBy<OmsorgsmånederForMottakerOgÅr> { it.haddeOmsorgIDesember() }.thenBy { it.omsorgsyter == grunnlag.omsorgsyter })
+                    .reversed()
+
+            fun oppgaveForPerson(): String {
+                return prioritert.first().omsorgsyter
+            }
+
+            fun annenPersonForInnhold(): String {
+                return prioritert.first { it.omsorgsyter != grunnlag.omsorgsyter }.omsorgsyter
+            }
+
+            fun omsorgsmottaker(): String {
+                return prioritert.first().omsorgsmottaker
+            }
+
+            fun omsorgsår(): Int {
+                return prioritert.first().omsorgsår
+            }
+        }
+    }
 
     data class Grunnlag(
         val omsorgsyter: String,

src/main/kotlin/no/nav/pensjon/opptjening/omsorgsopptjening/bestem/pensjonsopptjening/omsorgsopptjening/model/Utfall.kt

@@ -38,10 +38,13 @@ sealed class BehandlingUtfall {
     object Innvilget : BehandlingUtfall()
     object Avslag : BehandlingUtfall()
 
+    data object Manuell: BehandlingUtfall()
+
     fun erInnvilget(): Boolean {
         return when (this) {
             is Avslag -> false
             is Innvilget -> true
+            is Manuell -> false
         }
     }
 }

src/main/kotlin/no/nav/pensjon/opptjening/omsorgsopptjening/bestem/pensjonsopptjening/omsorgsopptjening/model/VilkarsVurdering.kt

@@ -29,4 +29,37 @@ inline fun <reified T : ParagrafVurdering<*>> VilkarsVurdering<*>.erEnesteAvslag
 
 inline fun <reified T : ParagrafVurdering<*>> VilkarsVurdering<*>.finnVurdering(): T {
     return UnwrapOgEllerVisitor.unwrap(this).filterIsInstance<T>().single()
+}
+
+fun VilkarsVurdering<*>.behovForManuellBehandling(): Boolean {
+    return hentVilkårSomMåbehandlesManuelt() != null
+}
+
+fun VilkarsVurdering<*>.hentVilkårSomMåbehandlesManuelt(): OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering? {
+    return avslagSkyldesFlereOmsorgsytereMedLikeMangeOmsorgsmåneder()
+}
+
+/**
+ * Det er bare aktuelt å lage oppgave i tilfeller hvor det ikke kan godskrives oppgjening som følge av at flere
+ * omsorgsyter har like mange omsorgsmåneder for det samme barnet i løpet av omsorgsåret.
+ */
+private fun VilkarsVurdering<*>.avslagSkyldesFlereOmsorgsytereMedLikeMangeOmsorgsmåneder(): OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering? {
+    return finnVurdering<OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering>().let {
+        if (erEnesteAvslag<OmsorgsyterHarMestOmsorgAvAlleOmsorgsytere.Vurdering>() && it.grunnlag.omsorgsyterErEnAvFlereMedFlestOmsorgsmåneder()) {
+            it
+        } else {
+            null
+        }
+    }
+}
+
+sealed class Oppgaveopplysning {
+    data class ToOmsorgsytereMedLikeMangeMånederOmsorg(
+        val oppgaveMottaker: String,
+        val annenOmsorgsyter: String,
+        val omsorgsmottaker: String,
+        val omsorgsår: Int,
+    ) : Oppgaveopplysning()
+
+    data object Ingen : Oppgaveopplysning()
 }

src/main/kotlin/no/nav/pensjon/opptjening/omsorgsopptjening/bestem/pensjonsopptjening/omsorgsopptjening/repository/UtfallDb.kt

@@ -44,10 +44,13 @@ internal sealed class VilkårsvurderingUtfallDb {
 internal sealed class BehandlingsutfallDb {
 
     @JsonTypeName("Avslag")
-    object Avslag : BehandlingsutfallDb()
+    data object Avslag : BehandlingsutfallDb()
 
     @JsonTypeName("Innvilget")
-    object Innvilget : BehandlingsutfallDb()
+    data object Innvilget : BehandlingsutfallDb()
+
+    @JsonTypeName("Manuell")
+    data object Manuell : BehandlingsutfallDb()
 }
 
 internal fun BehandlingUtfall.toDb(): BehandlingsutfallDb {
@@ -59,9 +62,31 @@ internal fun BehandlingUtfall.toDb(): BehandlingsutfallDb {
         BehandlingUtfall.Innvilget -> {
             BehandlingsutfallDb.Innvilget
         }
+
+        BehandlingUtfall.Manuell -> {
+            BehandlingsutfallDb.Manuell
+        }
+    }
+}
+
+
+internal fun BehandlingsutfallDb.toDomain(): BehandlingUtfall {
+    return when (this) {
+        is BehandlingsutfallDb.Innvilget -> {
+            BehandlingUtfall.Innvilget
+        }
+
+        is BehandlingsutfallDb.Avslag -> {
+            BehandlingUtfall.Avslag
+        }
+
+        is BehandlingsutfallDb.Manuell -> {
+            BehandlingUtfall.Manuell
+        }
     }
 }
 
+
 internal fun VilkårsvurderingUtfall.toDb(): VilkårsvurderingUtfallDb {
     return when (this) {
         is EllerAvslått -> {
@@ -116,16 +141,4 @@ internal fun VilkårsvurderingUtfallDb.toDomain(): VilkårsvurderingUtfall {
             VilkårsvurderingUtfall.Innvilget.Vilkår(henvisninger = henvisning.toDomain())
         }
     }
-}
-
-internal fun BehandlingsutfallDb.toDomain(): BehandlingUtfall {
-    return when (this) {
-        is BehandlingsutfallDb.Innvilget -> {
-            BehandlingUtfall.Innvilget
-        }
-
-        is BehandlingsutfallDb.Avslag -> {
-            BehandlingUtfall.Avslag
-        }
-    }
-}
+}