Bugfix/underhold (#605)

* Fikse sletting av notat ved sletting av annet barn i underhold. 409-respons ved opprettelse av duplikat underhold. Oppdatere tester * Underhold - Ikke tillate opprettelse av underhold for barn med samme navn og fødselsdato i samme behandling.
navikt · Nov 22, 2024 · 05ec00d · 05ec00d
1 parent b724026
commit 05ec00d
Show file tree

Hide file tree

Showing 6 changed files with 223 additions and 18 deletions.
diff --git a/src/main/kotlin/no/nav/bidrag/behandling/service/UnderholdService.kt b/src/main/kotlin/no/nav/bidrag/behandling/service/UnderholdService.kt
@@ -19,6 +19,7 @@ import no.nav.bidrag.behandling.dto.v2.underhold.StønadTilBarnetilsynDto
 import no.nav.bidrag.behandling.dto.v2.underhold.UnderholdDto
 import no.nav.bidrag.behandling.dto.v2.underhold.Underholdselement
 import no.nav.bidrag.behandling.transformers.Dtomapper
+import no.nav.bidrag.behandling.transformers.underhold.harAndreBarnIUnderhold
 import no.nav.bidrag.behandling.transformers.underhold.henteOgValidereUnderholdskostnad
 import no.nav.bidrag.behandling.transformers.underhold.tilStønadTilBarnetilsynDto
 import no.nav.bidrag.behandling.transformers.underhold.validere
@@ -111,7 +112,7 @@ class UnderholdService(
         behandling: Behandling,
         gjelderBarn: BarnDto,
     ): Underholdskostnad {
-        gjelderBarn.validere()
+        gjelderBarn.validere(behandling)
 
         return gjelderBarn.personident?.let { personidentBarn ->
             val rolleSøknadsbarn = behandling.søknadsbarn.find { it.ident == personidentBarn.verdi }
@@ -310,7 +311,9 @@ class UnderholdService(
         underholdskostnad.person.underholdskostnad.remove(underholdskostnad)
         if (underholdskostnad.person.underholdskostnad.isEmpty() && underholdskostnad.person.rolle.isEmpty()) {
             personRepository.deleteById(underholdskostnad.person.id!!)
-            notatService.sletteNotat(behandling, Notattype.UNDERHOLDSKOSTNAD, behandling.bidragsmottaker!!)
+            if (!behandling.harAndreBarnIUnderhold()) {
+                notatService.sletteNotat(behandling, Notattype.UNDERHOLDSKOSTNAD, behandling.bidragsmottaker!!)
+            }
         }
         underholdskostnadRepository.deleteById(underholdskostnad.id!!)
         return null
@@ -329,14 +332,8 @@ class UnderholdService(
         behandling: Behandling,
         person: Person,
     ): Underholdskostnad {
-        val eksisterendeUnderholdskostnad = behandling.underholdskostnader.find { it.person.id == person.id }
-
-        return if (eksisterendeUnderholdskostnad != null) {
-            eksisterendeUnderholdskostnad
-        } else {
-            val u = underholdskostnadRepository.save(Underholdskostnad(behandling = behandling, person = person))
-            behandling.underholdskostnader.add(u)
-            u
-        }
+        val u = underholdskostnadRepository.save(Underholdskostnad(behandling = behandling, person = person))
+        behandling.underholdskostnader.add(u)
+        return u
     }
 }
diff --git a/src/main/kotlin/no/nav/bidrag/behandling/transformers/underhold/Utvidelser.kt b/src/main/kotlin/no/nav/bidrag/behandling/transformers/underhold/Utvidelser.kt
@@ -1,6 +1,8 @@
 package no.nav.bidrag.behandling.transformers.underhold
 
 import no.nav.bidrag.behandling.database.datamodell.Barnetilsyn
+import no.nav.bidrag.behandling.database.datamodell.Behandling
+import no.nav.bidrag.behandling.dto.v2.underhold.BarnDto
 import no.nav.bidrag.behandling.dto.v2.underhold.DatoperiodeDto
 import no.nav.bidrag.behandling.dto.v2.underhold.StønadTilBarnetilsynDto
 import no.nav.bidrag.domene.enums.barnetilsyn.Skolealder
@@ -20,3 +22,15 @@ fun Barnetilsyn.tilStønadTilBarnetilsynDto(): StønadTilBarnetilsynDto =
     )
 
 fun Set<Barnetilsyn>.tilStønadTilBarnetilsynDtos() = map { it.tilStønadTilBarnetilsynDto() }.toSet()
+
+fun Behandling.harAndreBarnIUnderhold() = this.underholdskostnader.find { it.person.rolle.isEmpty() } != null
+
+fun BarnDto.annetBarnMedSammeNavnOgFødselsdatoEksistererFraFør(behandling: Behandling) =
+    behandling.underholdskostnader
+        .filter { it.person.ident == null }
+        .find { it.person.navn == this.navn && it.person.fødselsdato == this.fødselsdato } != null
+
+fun BarnDto.annetBarnMedSammePersonidentEksistererFraFør(behandling: Behandling) =
+    behandling.underholdskostnader
+        .filter { it.person.ident != null }
+        .find { it.person.ident == this.personident?.verdi } != null
diff --git a/src/main/kotlin/no/nav/bidrag/behandling/transformers/underhold/Validering.kt b/src/main/kotlin/no/nav/bidrag/behandling/transformers/underhold/Validering.kt
@@ -24,7 +24,7 @@ fun OppdatereUnderholdRequest.validere() {
     }
 }
 
-fun BarnDto.validere() {
+fun BarnDto.validere(behandling: Behandling) {
     if ((navn.isNullOrBlank() || fødselsdato == null) && (personident == null || personident.verdi.isEmpty())) {
         throw HttpClientErrorException(
             HttpStatus.BAD_REQUEST,
@@ -43,6 +43,20 @@ fun BarnDto.validere() {
             "Databaseid til barn skal ikke oppgis ved opprettelse av underholdskostnad.",
         )
     }
+
+    if (this.annetBarnMedSammePersonidentEksistererFraFør(behandling)) {
+        throw HttpClientErrorException(
+            HttpStatus.CONFLICT,
+            "Underhold for oppgitt barn eksisterer allerede i behandling ${behandling.id}).",
+        )
+    }
+
+    if (this.annetBarnMedSammeNavnOgFødselsdatoEksistererFraFør(behandling)) {
+        throw HttpClientErrorException(
+            HttpStatus.CONFLICT,
+            "Det finnes allerede underhold for barn med samme navn og fødselsdato i behandling ${behandling.id}.",
+        )
+    }
 }
 
 fun SletteUnderholdselement.validere(behandling: Behandling) {

diff --git a/src/test/kotlin/no/nav/bidrag/behandling/controller/UnderholdControllerTest.kt b/src/test/kotlin/no/nav/bidrag/behandling/controller/UnderholdControllerTest.kt
@@ -11,6 +11,7 @@ import io.kotest.matchers.shouldNotBe
 import no.nav.bidrag.behandling.database.datamodell.Person
 import no.nav.bidrag.behandling.database.datamodell.Underholdskostnad
 import no.nav.bidrag.behandling.database.repository.BehandlingRepository
+import no.nav.bidrag.behandling.database.repository.PersonRepository
 import no.nav.bidrag.behandling.database.repository.UnderholdskostnadRepository
 import no.nav.bidrag.behandling.dto.v2.underhold.BarnDto
 import no.nav.bidrag.behandling.dto.v2.underhold.DatoperiodeDto
@@ -28,6 +29,7 @@ import no.nav.bidrag.domene.enums.barnetilsyn.Skolealder
 import no.nav.bidrag.domene.enums.barnetilsyn.Tilsynstype
 import no.nav.bidrag.domene.enums.behandling.TypeBehandling
 import no.nav.bidrag.domene.enums.diverse.Kilde
+import no.nav.bidrag.domene.ident.Personident
 import no.nav.bidrag.transport.behandling.felles.grunnlag.NotatGrunnlag
 import org.junit.experimental.runners.Enclosed
 import org.junit.jupiter.api.Nested
@@ -52,6 +54,9 @@ class UnderholdControllerTest : KontrollerTestRunner() {
     @Autowired
     lateinit var underholdskostnadRepository: UnderholdskostnadRepository
 
+    @Autowired
+    lateinit var personRepository: PersonRepository
+
     @Nested
     open inner class Opprette {
         @Test
@@ -120,6 +125,37 @@ class UnderholdControllerTest : KontrollerTestRunner() {
                 )
             }
         }
+
+        @Test
+        @Transactional
+        open fun `skal ikke opprette ny person for annet barn oppgitt med personident dersom person med samme ident allerede eksisterer`() {
+            // gitt
+            val behandling = oppretteTestbehandling(inkludereBp = true, behandlingstype = TypeBehandling.BIDRAG)
+            val eksisterendePerson = Person(ident = "11223312345")
+            testdataManager.lagrePersonIEgenTransaksjon(eksisterendePerson)
+
+            testdataManager.lagreBehandlingNewTransaction(behandling)
+
+            val request = BarnDto(personident = Personident(eksisterendePerson.ident!!))
+
+            // hvis
+            httpHeaderTestRestTemplate.exchange(
+                "${rootUriV2()}/behandling/${behandling.id}/underhold/opprette",
+                HttpMethod.POST,
+                HttpEntity(request),
+                UnderholdDto::class.java,
+            )
+
+            // så
+            val p = personRepository.findAll()
+            p.filter { it.ident == eksisterendePerson.ident } shouldHaveSize 1
+
+            assertSoftly(personRepository.findAll().filter { it.ident == eksisterendePerson.ident }) {
+                shouldHaveSize(1)
+                it.first().underholdskostnad shouldHaveSize 1
+                it.first().rolle shouldHaveSize 0
+            }
+        }
     }
 
     @Nested

diff --git a/src/test/kotlin/no/nav/bidrag/behandling/service/UnderholdServiceTest.kt b/src/test/kotlin/no/nav/bidrag/behandling/service/UnderholdServiceTest.kt
@@ -41,12 +41,14 @@ import no.nav.bidrag.domene.enums.barnetilsyn.Skolealder
 import no.nav.bidrag.domene.enums.barnetilsyn.Tilsynstype
 import no.nav.bidrag.domene.enums.behandling.TypeBehandling
 import no.nav.bidrag.domene.enums.diverse.Kilde
+import no.nav.bidrag.domene.ident.Personident
 import no.nav.bidrag.transport.behandling.felles.grunnlag.NotatGrunnlag
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Nested
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
+import org.springframework.http.HttpStatus
 import org.springframework.web.client.HttpClientErrorException
 import stubPersonConsumer
 import java.math.BigDecimal
@@ -121,9 +123,13 @@ class UnderholdServiceTest {
 
         every { underholdskostnadRepository.save(any()) }.answers {
             val underholdskostnad = firstArg<Underholdskostnad>()
-            underholdskostnad.tilleggsstønad.forEachIndexed { index, tilleggsstønad -> tilleggsstønad.id = index.toLong() }
+            underholdskostnad.tilleggsstønad.forEachIndexed { index, tilleggsstønad ->
+                tilleggsstønad.id = index.toLong()
+            }
             underholdskostnad.barnetilsyn.forEachIndexed { index, barnetilsyn -> barnetilsyn.id = index.toLong() }
-            underholdskostnad.faktiskeTilsynsutgifter.forEachIndexed { index, faktiskeTilsynsutgifter -> faktiskeTilsynsutgifter.id = index.toLong() }
+            underholdskostnad.faktiskeTilsynsutgifter.forEachIndexed { index, faktiskeTilsynsutgifter ->
+                faktiskeTilsynsutgifter.id = index.toLong()
+            }
             underholdskostnad
         }
     }
@@ -219,6 +225,67 @@ class UnderholdServiceTest {
 
             behandling.notater.find { it.rolle == behandling.bidragsmottaker }.shouldBeNull()
         }
+
+        @Test
+        open fun `skal ikke slette notat ved sletting av underhold så lenge det finnes andre barn`() {
+            // gitt
+            val universalid = 1L
+            val behandling =
+                oppretteTestbehandling(
+                    setteDatabaseider = true,
+                    inkludereBp = true,
+                    behandlingstype = TypeBehandling.BIDRAG,
+                )
+
+            val generalen = Person(id = 10, navn = "Generalen", fødselsdato = LocalDate.now())
+            val kostnadForUnderholdAvGeneralen =
+                Underholdskostnad(id = 100, behandling = behandling, person = generalen)
+            behandling.underholdskostnader.add(kostnadForUnderholdAvGeneralen)
+
+            val flaggkommandøren = Person(id = 11, navn = "Flaggkommandøren", fødselsdato = LocalDate.now())
+            val kostnadForUnderholdAvFlaggkommandøren =
+                Underholdskostnad(id = 101, behandling = behandling, person = flaggkommandøren)
+            behandling.underholdskostnader.add(kostnadForUnderholdAvFlaggkommandøren)
+
+            notatService.oppdatereNotat(
+                behandling,
+                NotatGrunnlag.NotatType.UNDERHOLDSKOSTNAD,
+                "Begrunnelse for andre barn",
+                behandling.bidragsmottaker!!,
+            )
+
+            val request = SletteUnderholdselement(idUnderhold = 100, idElement = 10, Underholdselement.BARN)
+
+            every { underholdskostnadRepository.deleteById(kostnadForUnderholdAvGeneralen.id!!) } returns Unit
+            every { personRepository.deleteById(generalen.id!!) } returns Unit
+
+            assertSoftly(behandling.underholdskostnader.find { it.id == kostnadForUnderholdAvGeneralen.id!! }) {
+                shouldNotBeNull()
+                person.id shouldBe generalen.id
+            }
+
+            assertSoftly(behandling.notater.find { it.rolle == behandling.bidragsmottaker }) {
+                shouldNotBeNull()
+                innhold shouldBe "Begrunnelse for andre barn"
+            }
+
+            // hvis
+            underholdService.sletteFraUnderhold(behandling, request)
+
+            // så
+            val u = behandling.underholdskostnader.find { it.id == universalid }
+            u.shouldNotBeNull()
+            u.tilleggsstønad.shouldBeEmpty()
+
+            behandling.underholdskostnader.find { it.id == kostnadForUnderholdAvGeneralen.id!! }.shouldBeNull()
+
+            assertSoftly(behandling.notater.find { it.rolle == behandling.bidragsmottaker }) {
+                shouldNotBeNull()
+                rolle shouldBe behandling.bidragsmottaker!!
+                innhold shouldBe "Begrunnelse for andre barn"
+                type shouldBe NotatGrunnlag.NotatType.UNDERHOLDSKOSTNAD
+            }
+        }
     }
 
     @Nested
@@ -227,18 +294,18 @@ class UnderholdServiceTest {
         @Test
         open fun `skal opprette underholdskostnad ved opprettelse av nytt barn`() {
             // gitt
-            val universalid = 1L
-            val navnAnnetBarnBp = "Stig E. Spill"
-            val fødselsdatoAnnetBarnBp = LocalDate.now().minusMonths(96)
             val behandling =
                 oppretteTestbehandling(
                     setteDatabaseider = true,
                     inkludereBp = true,
                     behandlingstype = TypeBehandling.BIDRAG,
                 )
+            val universalid = 1L
+            val navnAnnetBarnBp = "Stig E. Spill"
+            val fødselsdatoAnnetBarnBp = LocalDate.now().minusMonths(96)
 
             val request = BarnDto(navn = navnAnnetBarnBp, fødselsdato = fødselsdatoAnnetBarnBp)
-            val barn = Person(navn = navnAnnetBarnBp, fødselsdato = fødselsdatoAnnetBarnBp)
+            val barn = Person(id = 100, navn = navnAnnetBarnBp, fødselsdato = fødselsdatoAnnetBarnBp)
 
             every { personRepository.save(any()) } returns barn
             every { underholdskostnadRepository.save(any()) } returns
@@ -256,6 +323,79 @@ class UnderholdServiceTest {
             u.shouldNotBeNull()
             u.tilleggsstønad.shouldBeEmpty()
         }
+
+        @Test
+        open fun `skal ikke være mulig å opprette mer enn ett underhold per barn oppgitt med personident per behandling`() {
+            // gitt
+            val behandling =
+                oppretteTestbehandling(
+                    setteDatabaseider = true,
+                    inkludereBp = true,
+                    behandlingstype = TypeBehandling.BIDRAG,
+                )
+
+            val annetBarnMedPersonident = Person(ident = "11223312345")
+
+            behandling.underholdskostnader.add(
+                Underholdskostnad(id = 101, behandling = behandling, person = annetBarnMedPersonident),
+            )
+
+            val request = BarnDto(personident = Personident(annetBarnMedPersonident.ident!!))
+
+            every { personRepository.save(any()) } returns annetBarnMedPersonident
+            every { personRepository.findFirstByIdent(annetBarnMedPersonident.ident!!) } returns annetBarnMedPersonident
+            every { underholdskostnadRepository.save(any()) } returns
+                Underholdskostnad(
+                    id = 102,
+                    behandling = behandling,
+                    person = annetBarnMedPersonident,
+                )
+
+            // hvis
+            val respons =
+                assertFailsWith<HttpClientErrorException> {
+                    underholdService.oppretteUnderholdskostnad(behandling, request)
+                }
+
+            // så
+            respons.statusCode shouldBe HttpStatus.CONFLICT
+        }
+
+        @Test
+        open fun `skal ikke være mulig å opprette mer enn ett underhold per barn oppgitt med navn og fødselsdato per behandling`() {
+            // gitt
+            val behandling =
+                oppretteTestbehandling(
+                    setteDatabaseider = true,
+                    inkludereBp = true,
+                    behandlingstype = TypeBehandling.BIDRAG,
+                )
+
+            val generalen = Person(navn = "Generalen", fødselsdato = LocalDate.now())
+
+            behandling.underholdskostnader.add(
+                Underholdskostnad(id = 101, behandling = behandling, person = generalen),
+            )
+
+            val request = BarnDto(navn = generalen.navn, fødselsdato = generalen.fødselsdato)
+
+            every { personRepository.save(any()) } returns generalen
+            every { underholdskostnadRepository.save(any()) } returns
+                Underholdskostnad(
+                    id = 102,
+                    behandling = behandling,
+                    person = generalen,
+                )
+
+            // hvis
+            val respons =
+                assertFailsWith<HttpClientErrorException> {
+                    underholdService.oppretteUnderholdskostnad(behandling, request)
+                }
+
+            // så
+            respons.statusCode shouldBe HttpStatus.CONFLICT
+        }
     }
 
     @Nested

diff --git a/src/test/kotlin/no/nav/bidrag/behandling/utils/testdata/TestdataManager.kt b/src/test/kotlin/no/nav/bidrag/behandling/utils/testdata/TestdataManager.kt
@@ -5,6 +5,7 @@ import jakarta.transaction.Transactional
 import no.nav.bidrag.behandling.database.datamodell.Behandling
 import no.nav.bidrag.behandling.database.datamodell.Grunnlag
 import no.nav.bidrag.behandling.database.datamodell.Inntekt
+import no.nav.bidrag.behandling.database.datamodell.Person
 import no.nav.bidrag.behandling.database.datamodell.Rolle
 import no.nav.bidrag.behandling.database.datamodell.Underholdskostnad
 import no.nav.bidrag.behandling.database.grunnlag.SkattepliktigeInntekter
@@ -54,6 +55,9 @@ class TestdataManager(
         return behandlingRepository.save(behandling)
     }
 
+    @Transactional(Transactional.TxType.REQUIRES_NEW)
+    fun lagrePersonIEgenTransaksjon(person: Person) = personRepository.save(person)
+
     @Transactional(Transactional.TxType.REQUIRES_NEW)
     fun oppretteBehandlingINyTransaksjon(
         inkluderInntekter: Boolean = false,