Oppretter oppgave ved opprettelse av tilbakekrevingsbehandling

client/src/main/kotlin/no/nav/su/se/bakover/client/oppgave/OppgaveHttpClient.kt

@@ -174,6 +174,12 @@ internal class OppgaveHttpClient(
                     Tidspunkt.now(clock).toOppgaveFormat()
                 } - Opprettet av Supplerende Stønad ---\nSaksnummer : ${config.saksreferanse}\nEndring i institusjonsopphold"
             }
+
+            is OppgaveConfig.Tilbakekrevingsbehandling -> {
+                "--- ${
+                    Tidspunkt.now(clock).toOppgaveFormat()
+                } - Opprettet av Supplerende Stønad ---\nSaksnummer : ${config.saksreferanse}"
+            }
         }
 
         return Either.catch {

domain/src/main/kotlin/no/nav/su/se/bakover/domain/Kodeverk.kt

@@ -27,6 +27,9 @@ enum class Behandlingstype(val value: String) {
 
     /** UFOR_FLYKT_KLAGE_SUP;ab0431;ae0058;SUP */
     KLAGE("ae0058"),
+
+    /** UFOR_FLYKT_TILBK_SUP;ab0431;ae0203;SUP */
+    TILBAKEKREVING("ae0203"),
     ;
 
     override fun toString() = this.value

domain/src/main/kotlin/no/nav/su/se/bakover/domain/oppgave/OppgaveConfig.kt

@@ -79,6 +79,21 @@ sealed class OppgaveConfig {
         override val fristFerdigstillelse: LocalDate = aktivDato.plusDays(30)
     }
 
+    data class Tilbakekrevingsbehandling(
+        val saksnummer: Saksnummer,
+        override val aktørId: AktørId,
+        override val tilordnetRessurs: NavIdentBruker?,
+        override val clock: Clock,
+    ) : OppgaveConfig() {
+        override val saksreferanse = saksnummer.toString()
+        override val journalpostId: JournalpostId? = null
+        override val behandlingstema = Behandlingstema.SU_UFØRE_FLYKTNING
+        override val behandlingstype = Behandlingstype.TILBAKEKREVING
+        override val oppgavetype = Oppgavetype.BEHANDLE_SAK
+        override val aktivDato: LocalDate = LocalDate.now(clock)
+        override val fristFerdigstillelse: LocalDate = aktivDato.plusDays(30)
+    }
+
     data class AttesterRevurdering(
         val saksnummer: Saksnummer,
         override val aktørId: AktørId,

tilbakekreving/application/build.gradle.kts

@@ -8,6 +8,8 @@ dependencies {
     implementation(project(":person:domain"))
     implementation(project(":service"))
 
+    implementation(project(":oppgave:domain"))
+
     testImplementation(project(":test-common"))
 }
 

tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/TilbakekrevingServices.kt

@@ -2,10 +2,12 @@ package tilbakekreving.application.service
 
 import arrow.core.Either
 import no.nav.su.se.bakover.common.persistence.SessionFactory
+import no.nav.su.se.bakover.domain.oppgave.OppgaveService
 import no.nav.su.se.bakover.domain.person.PersonRepo
 import no.nav.su.se.bakover.domain.person.PersonService
 import no.nav.su.se.bakover.domain.sak.SakService
 import no.nav.su.se.bakover.hendelse.domain.HendelsekonsumenterRepo
+import no.nav.su.se.bakover.oppgave.domain.OppgaveHendelseRepo
 import no.nav.su.se.bakover.service.tilbakekreving.TilbakekrevingService
 import tilbakekreving.application.service.common.TilbakekrevingsbehandlingTilgangstyringService
 import tilbakekreving.application.service.consumer.KnyttKravgrunnlagTilSakOgUtbetalingKonsument
@@ -33,7 +35,9 @@ class TilbakekrevingServices(
     private val hendelsekonsumenterRepo: HendelsekonsumenterRepo,
     private val tilbakekrevingService: TilbakekrevingService,
     private val sakService: SakService,
+    private val oppgaveService: OppgaveService,
     private val tilbakekrevingsbehandlingRepo: TilbakekrevingsbehandlingRepo,
+    private val oppgaveHendelseRepo: OppgaveHendelseRepo,
     private val mapRåttKravgrunnlag: (RåttKravgrunnlag) -> Either<Throwable, Kravgrunnlag>,
     private val tilgangstyringService: TilbakekrevingsbehandlingTilgangstyringService = TilbakekrevingsbehandlingTilgangstyringService(
         personRepo = personRepo,
@@ -65,6 +69,10 @@ class TilbakekrevingServices(
         tilgangstyring = tilgangstyringService,
         clock = clock,
         sakService = sakService,
+        oppgaveService = oppgaveService,
+        personService = personService,
+        oppgaveHendelseRepo = oppgaveHendelseRepo,
+        sessionFactory = sessionFactory,
     ),
     val råttKravgrunnlagService: RåttKravgrunnlagService = RåttKravgrunnlagService(
         kravgrunnlagRepo = kravgrunnlagRepo,

tilbakekreving/application/src/main/kotlin/tilbakekreving/application/service/opprett/OpprettTilbakekrevingsbehandlingService.kt

@@ -4,10 +4,21 @@ import arrow.core.Either
 import arrow.core.getOrElse
 import arrow.core.left
 import arrow.core.right
+import no.nav.su.se.bakover.common.persistence.SessionFactory
+import no.nav.su.se.bakover.common.tid.Tidspunkt
+import no.nav.su.se.bakover.domain.Sak
+import no.nav.su.se.bakover.domain.oppgave.OppgaveConfig
+import no.nav.su.se.bakover.domain.oppgave.OppgaveService
+import no.nav.su.se.bakover.domain.person.PersonService
 import no.nav.su.se.bakover.domain.sak.SakService
+import no.nav.su.se.bakover.hendelse.domain.DefaultHendelseMetadata
+import no.nav.su.se.bakover.hendelse.domain.HendelseId
+import no.nav.su.se.bakover.oppgave.domain.OppgaveHendelse
+import no.nav.su.se.bakover.oppgave.domain.OppgaveHendelseRepo
 import org.slf4j.LoggerFactory
 import tilbakekreving.application.service.common.TilbakekrevingsbehandlingTilgangstyringService
 import tilbakekreving.domain.OpprettetTilbakekrevingsbehandling
+import tilbakekreving.domain.OpprettetTilbakekrevingsbehandlingHendelse
 import tilbakekreving.domain.opprett.KunneIkkeOppretteTilbakekrevingsbehandling
 import tilbakekreving.domain.opprett.OpprettTilbakekrevingsbehandlingCommand
 import tilbakekreving.domain.opprett.TilbakekrevingsbehandlingRepo
@@ -18,6 +29,10 @@ class OpprettTilbakekrevingsbehandlingService(
     private val tilbakekrevingsbehandlingRepo: TilbakekrevingsbehandlingRepo,
     private val tilgangstyring: TilbakekrevingsbehandlingTilgangstyringService,
     private val sakService: SakService,
+    private val oppgaveService: OppgaveService,
+    private val personService: PersonService,
+    private val oppgaveHendelseRepo: OppgaveHendelseRepo,
+    private val sessionFactory: SessionFactory,
     private val clock: Clock,
 ) {
     private val log = LoggerFactory.getLogger(this::class.java)
@@ -45,9 +60,49 @@ class OpprettTilbakekrevingsbehandlingService(
                 clock = clock,
                 kravgrunnlag = k,
             ).let { (hendelse, behandling) ->
-                tilbakekrevingsbehandlingRepo.lagre(hendelse)
+                val oppgaveHendelse = opprettOppgaveHendelse(hendelse, sak, command).getOrElse { return it.left() }
+
+                sessionFactory.withTransactionContext {
+                    tilbakekrevingsbehandlingRepo.lagre(hendelse, it)
+                    oppgaveHendelseRepo.lagre(oppgaveHendelse, it)
+                }
                 behandling.right()
             }
         }
     }
+
+    private fun opprettOppgaveHendelse(
+        relaterteHendelse: OpprettetTilbakekrevingsbehandlingHendelse,
+        sak: Sak,
+        command: OpprettTilbakekrevingsbehandlingCommand,
+    ): Either<KunneIkkeOppretteTilbakekrevingsbehandling, OppgaveHendelse> {
+        val aktørId = personService.hentAktørId(sak.fnr).getOrElse {
+            return KunneIkkeOppretteTilbakekrevingsbehandling.FeilVedHentingAvPerson(it).left()
+        }
+
+        val oppgaveId = oppgaveService.opprettOppgave(
+            OppgaveConfig.Tilbakekrevingsbehandling(
+                saksnummer = sak.saksnummer,
+                aktørId = aktørId,
+                tilordnetRessurs = command.opprettetAv,
+                clock = clock,
+            ),
+        ).getOrElse {
+            return KunneIkkeOppretteTilbakekrevingsbehandling.FeilVedOpprettelseAvOppgave.left()
+        }
+
+        return OppgaveHendelse.opprettet(
+            hendelseId = HendelseId.generer(),
+            hendelsestidspunkt = Tidspunkt.now(clock),
+            oppgaveId = oppgaveId,
+            versjon = relaterteHendelse.versjon.inc(),
+            sakId = sak.id,
+            relaterteHendelser = listOf(relaterteHendelse.hendelseId),
+            meta = DefaultHendelseMetadata(
+                correlationId = command.correlationId,
+                ident = command.opprettetAv,
+                brukerroller = command.brukerroller,
+            ),
+        ).right()
+    }
 }

tilbakekreving/application/src/test/kotlin/tilbakekreving/application/service/OpprettTilbakekrevingsbehandlingServiceTest.kt

@@ -5,10 +5,18 @@ import arrow.core.right
 import io.kotest.assertions.arrow.core.shouldBeRight
 import io.kotest.matchers.shouldBe
 import no.nav.su.se.bakover.common.brukerrolle.Brukerrolle
+import no.nav.su.se.bakover.common.domain.oppgave.OppgaveId
 import no.nav.su.se.bakover.common.extensions.februar
+import no.nav.su.se.bakover.common.person.AktørId
+import no.nav.su.se.bakover.domain.oppgave.OppgaveConfig
+import no.nav.su.se.bakover.domain.oppgave.OppgaveService
+import no.nav.su.se.bakover.domain.person.PersonService
 import no.nav.su.se.bakover.domain.sak.SakService
 import no.nav.su.se.bakover.hendelse.domain.DefaultHendelseMetadata
 import no.nav.su.se.bakover.hendelse.domain.Hendelsesversjon
+import no.nav.su.se.bakover.oppgave.domain.OppgaveHendelse
+import no.nav.su.se.bakover.oppgave.domain.OppgaveHendelseRepo
+import no.nav.su.se.bakover.test.TestSessionFactory
 import no.nav.su.se.bakover.test.TikkendeKlokke
 import no.nav.su.se.bakover.test.argThat
 import no.nav.su.se.bakover.test.correlationId
@@ -46,15 +54,22 @@ class OpprettTilbakekrevingsbehandlingServiceTest {
         val tilgangstyringService = mock<TilbakekrevingsbehandlingTilgangstyringService> {
             on { assertHarTilgangTilSak(any()) } doReturn Unit.right()
         }
-
         val sakService = mock<SakService> {
             on { hentSak(any<UUID>()) } doReturn sakMedKravgrunnlag.right()
         }
+        val personService = mock<PersonService> {
+            on { hentAktørId(any()) } doReturn AktørId("aktørId").right()
+        }
+        val oppgaveService = mock<OppgaveService> {
+            on { opprettOppgave(any()) } doReturn OppgaveId("oppgaveId").right()
+        }
 
         val mocks = mockedServices(
             tilgangstyringService = tilgangstyringService,
             sakService = sakService,
             clock = clock,
+            personService = personService,
+            oppgaveService = oppgaveService,
         )
         mocks.service().opprett(
             command = OpprettTilbakekrevingsbehandlingCommand(
@@ -67,10 +82,22 @@ class OpprettTilbakekrevingsbehandlingServiceTest {
         ).shouldBeRight()
 
         verify(mocks.sakService).hentSak(
-            argThat<UUID> {
-                it shouldBe sakId
+            argThat<UUID> { it shouldBe sakId },
+        )
+        verify(mocks.personService).hentAktørId(
+            argThat { it shouldBe sakMedKravgrunnlag.fnr },
+        )
+        verify(mocks.oppgaveService).opprettOppgave(
+            argThat {
+                it shouldBe OppgaveConfig.Tilbakekrevingsbehandling(
+                    saksnummer = sakMedKravgrunnlag.saksnummer,
+                    aktørId = AktørId(aktørId = "aktørId"),
+                    tilordnetRessurs = saksbehandler,
+                    clock = clock,
+                )
             },
         )
+
         verify(mocks.tilbakekrevingsbehandlingRepo).lagre(
             argThat {
                 it shouldBe OpprettetTilbakekrevingsbehandlingHendelse(
@@ -90,6 +117,26 @@ class OpprettTilbakekrevingsbehandlingServiceTest {
             },
             anyOrNull(),
         )
+        verify(mocks.oppgaveHendelseRepo).lagre(
+            argThat {
+                it shouldBe OppgaveHendelse.opprettet(
+                    hendelseId = it.hendelseId, // Denne blir generert av domenet.
+                    sakId = sakId,
+                    versjon = Hendelsesversjon(value = 3),
+                    hendelsestidspunkt = it.hendelsestidspunkt, // vi bruker tikkende-klokke
+                    meta = DefaultHendelseMetadata(
+                        correlationId = correlationId,
+                        ident = saksbehandler,
+                        brukerroller = brukerroller,
+                    ),
+                    oppgaveId = OppgaveId(value = "oppgaveId"),
+                    relaterteHendelser = it.relaterteHendelser.also {
+                        it.size shouldBe 1
+                    },
+                )
+            },
+            anyOrNull(),
+        )
         mocks.verifyNoMoreInteractions()
     }
 
@@ -98,13 +145,21 @@ class OpprettTilbakekrevingsbehandlingServiceTest {
         val tilgangstyringService: TilbakekrevingsbehandlingTilgangstyringService = mock(),
         val clock: Clock = fixedClock,
         val sakService: SakService = mock(),
+        val oppgaveService: OppgaveService = mock(),
+        val personService: PersonService = mock(),
+        val oppgaveHendelseRepo: OppgaveHendelseRepo = mock(),
+        val sessionFactory: TestSessionFactory = TestSessionFactory(),
     ) {
         fun service(): OpprettTilbakekrevingsbehandlingService =
             OpprettTilbakekrevingsbehandlingService(
                 tilbakekrevingsbehandlingRepo = tilbakekrevingsbehandlingRepo,
                 tilgangstyring = tilgangstyringService,
                 sakService = sakService,
                 clock = clock,
+                oppgaveService = oppgaveService,
+                personService = personService,
+                oppgaveHendelseRepo = oppgaveHendelseRepo,
+                sessionFactory = sessionFactory,
             )
 
         fun verifyNoMoreInteractions() {

tilbakekreving/domain/src/main/kotlin/tilbakekreving/domain/opprett/KunneIkkeOppretteTilbakekrevingsbehandling.kt

@@ -1,9 +1,13 @@
 package tilbakekreving.domain.opprett
 
+import person.domain.KunneIkkeHentePerson
 import tilbakekreving.domain.IkkeTilgangTilSak
 
 sealed interface KunneIkkeOppretteTilbakekrevingsbehandling {
     data object IngenÅpneKravgrunnlag : KunneIkkeOppretteTilbakekrevingsbehandling
     data object FinnesAlleredeEnÅpenBehandling : KunneIkkeOppretteTilbakekrevingsbehandling
+    data class FeilVedHentingAvPerson(val feil: KunneIkkeHentePerson) : KunneIkkeOppretteTilbakekrevingsbehandling
+
     data class IkkeTilgang(val underliggende: IkkeTilgangTilSak) : KunneIkkeOppretteTilbakekrevingsbehandling
+    data object FeilVedOpprettelseAvOppgave : KunneIkkeOppretteTilbakekrevingsbehandling
 }

tilbakekreving/infrastructure/build.gradle.kts

@@ -11,6 +11,7 @@ dependencies {
     implementation(project(":hendelse:infrastructure"))
     implementation(project(":hendelse:domain"))
     implementation(project(":økonomi:domain"))
+    implementation(project(":oppgave:domain"))
 
     testImplementation(project(":test-common"))
 }

tilbakekreving/infrastructure/src/main/kotlin/tilbakekreving/infrastructure/TilbakekrevingRepos.kt

@@ -3,6 +3,7 @@ package tilbakekreving.infrastructure
 import no.nav.su.se.bakover.common.persistence.SessionFactory
 import no.nav.su.se.bakover.hendelse.domain.HendelseRepo
 import no.nav.su.se.bakover.hendelse.domain.HendelsekonsumenterRepo
+import no.nav.su.se.bakover.oppgave.domain.OppgaveHendelseRepo
 import tilbakekreving.domain.kravgrunnlag.KravgrunnlagRepo
 import tilbakekreving.domain.opprett.TilbakekrevingsbehandlingRepo
 import java.time.Clock
@@ -17,6 +18,7 @@ class TilbakekrevingRepos(
     val sessionFactory: SessionFactory,
     val hendelseRepo: HendelseRepo,
     val hendelsekonsumenterRepo: HendelsekonsumenterRepo,
+    val oppgaveHendelseRepo: OppgaveHendelseRepo,
     val kravgrunnlagRepo: KravgrunnlagRepo = KravgrunnlagPostgresRepo(
         hendelseRepo = hendelseRepo,
         hendelsekonsumenterRepo = hendelsekonsumenterRepo,

tilbakekreving/presentation/build.gradle.kts

@@ -9,6 +9,7 @@ dependencies {
     implementation(project(":hendelse:infrastructure"))
     implementation(project(":hendelse:domain"))
     implementation(project(":dokument:domain"))
+    implementation(project(":person:domain"))
 
     implementation(project(":domain"))
     implementation(project(":service"))

tilbakekreving/presentation/src/main/kotlin/tilbakekreving/presentation/api/opprett/OpprettTilbakekrevingsbehandlingRoute.kt

@@ -15,6 +15,7 @@ import no.nav.su.se.bakover.common.infrastructure.web.svar
 import no.nav.su.se.bakover.common.infrastructure.web.withBody
 import no.nav.su.se.bakover.common.infrastructure.web.withSakId
 import no.nav.su.se.bakover.hendelse.domain.Hendelsesversjon
+import person.domain.KunneIkkeHentePerson
 import tilbakekreving.application.service.opprett.OpprettTilbakekrevingsbehandlingService
 import tilbakekreving.domain.opprett.KunneIkkeOppretteTilbakekrevingsbehandling
 import tilbakekreving.domain.opprett.OpprettTilbakekrevingsbehandlingCommand
@@ -56,4 +57,13 @@ private fun KunneIkkeOppretteTilbakekrevingsbehandling.tilResultat(): Resultat =
     is KunneIkkeOppretteTilbakekrevingsbehandling.IngenÅpneKravgrunnlag -> ingenÅpneKravgrunnlag
     is KunneIkkeOppretteTilbakekrevingsbehandling.IkkeTilgang -> ikkeTilgangTilSak
     is KunneIkkeOppretteTilbakekrevingsbehandling.FinnesAlleredeEnÅpenBehandling -> Feilresponser.harAlleredeÅpenBehandling
+    is KunneIkkeOppretteTilbakekrevingsbehandling.FeilVedHentingAvPerson -> this.feil.tilResultat()
+    KunneIkkeOppretteTilbakekrevingsbehandling.FeilVedOpprettelseAvOppgave -> TODO()
+}
+
+// dobbel-impl av person routes
+internal fun KunneIkkeHentePerson.tilResultat(): Resultat = when (this) {
+    KunneIkkeHentePerson.FantIkkePerson -> Feilresponser.fantIkkePerson
+    KunneIkkeHentePerson.IkkeTilgangTilPerson -> Feilresponser.ikkeTilgangTilPerson
+    KunneIkkeHentePerson.Ukjent -> Feilresponser.feilVedOppslagPåPerson
 }

web-regresjonstest/build.gradle.kts

@@ -16,6 +16,7 @@ dependencies {
     implementation(project(":økonomi:infrastructure"))
     implementation(project(":økonomi:domain"))
     implementation(project(":dokument:domain"))
+    implementation(project(":oppgave:domain"))
 
     implementation(project(":hendelse:domain"))
     implementation(project(":hendelse:infrastructure"))

web-regresjonstest/src/main/kotlin/no/nav/su/se/bakover/web/SharedRegressionTestData.kt

@@ -171,6 +171,7 @@ data object SharedRegressionTestData {
                         sessionFactory = databaseRepos.sessionFactory,
                         hendelseRepo = databaseRepos.hendelseRepo,
                         hendelsekonsumenterRepo = databaseRepos.hendelsekonsumenterRepo,
+                        oppgaveHendelseRepo = databaseRepos.oppgaveHendelseRepo,
                     )
                     Tilbakekrevingskomponenter(
                         repos = repos,
@@ -185,6 +186,8 @@ data object SharedRegressionTestData {
                             sakService = services.sak,
                             tilbakekrevingsbehandlingRepo = repos.tilbakekrevingsbehandlingRepo,
                             mapRåttKravgrunnlag = TilbakekrevingsmeldingMapper::toKravgrunnlag,
+                            oppgaveService = services.oppgave,
+                            oppgaveHendelseRepo = repos.oppgaveHendelseRepo,
                         ),
                     )
                 },

web-regresjonstest/src/main/kotlin/no/nav/su/se/bakover/web/komponenttest/Komponenttest.kt

@@ -112,6 +112,7 @@ internal fun withKomptestApplication(
             sessionFactory = databaseRepos.sessionFactory,
             hendelseRepo = databaseRepos.hendelseRepo,
             hendelsekonsumenterRepo = databaseRepos.hendelsekonsumenterRepo,
+            oppgaveHendelseRepo = databaseRepos.oppgaveHendelseRepo,
         )
         Tilbakekrevingskomponenter(
             repos = repos,
@@ -126,6 +127,8 @@ internal fun withKomptestApplication(
                 sakService = services.sak,
                 tilbakekrevingsbehandlingRepo = repos.tilbakekrevingsbehandlingRepo,
                 mapRåttKravgrunnlag = TilbakekrevingsmeldingMapper::toKravgrunnlag,
+                oppgaveService = services.oppgave,
+                oppgaveHendelseRepo = repos.oppgaveHendelseRepo,
             ),
         )
     },