From b921d76761d2e7c713373feb7eea1dd677e4fd29 Mon Sep 17 00:00:00 2001 From: Trine Linderud Date: Tue, 22 Oct 2024 13:42:50 +0200 Subject: [PATCH] =?UTF-8?q?=E2=99=BB=EF=B8=8F=20Godkjenningsbehov=20kan=20?= =?UTF-8?q?kj=C3=B8res=20transaksjonelt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../src/main/kotlin/no/nav/helse/HelseDao.kt | 26 +++++ .../no/nav/helse/db/AvviksvurderingDao.kt | 72 ++------------ .../nav/helse/db/AvviksvurderingRepository.kt | 3 + .../no/nav/helse/db/InntektskilderDao.kt | 79 --------------- .../db/TransactionalArbeidsforholdDao.kt | 98 +++++++++++++++++++ .../db/TransactionalAvviksvurderingDao.kt | 53 ++++++++++ .../db/TransactionalInntektskilderDao.kt | 59 ++++++++++- .../nav/helse/db/TransactionalOppgaveDao.kt | 13 ++- .../helse/db/TransactionalOverstyringDao.kt | 53 +++++++++- .../no/nav/helse/db/TransactionalPersonDao.kt | 40 ++++++-- .../db/TransactionalP\303\245VentDao.kt" | 22 +++++ .../db/TransactionalRisikovurderingDao.kt | 28 +++++- .../db/TransactionalTotrinnsvurderingDao.kt | 19 ++-- .../helse/db/TransactionalUtbetalingDao.kt | 15 ++- .../no/nav/helse/db/TransactionalVedtakDao.kt | 35 ++++++- .../db/TransactionalVergem\303\245lDao.kt" | 29 +++++- .../no/nav/helse/mediator/Kommandofabrikk.kt | 81 +++++++-------- .../nav/helse/mediator/oppgave/OppgaveDao.kt | 10 +- .../kotlin/no/nav/helse/modell/VedtakDao.kt | 30 +----- .../arbeidsforhold/ArbeidsforholdDao.kt | 88 +---------------- .../modell/overstyring/OverstyringDao.kt | 55 ++--------- .../no/nav/helse/modell/person/PersonDao.kt | 58 +---------- .../nav/helse/modell/person/PersonService.kt | 7 +- .../modell/p\303\245vent/P\303\245VentDao.kt" | 16 +-- .../helse/modell/risiko/RisikovurderingDao.kt | 35 ++----- .../helse/modell/utbetaling/UtbetalingDao.kt | 18 +--- .../vedtaksperiode/Godkjenningsbehov.kt | 13 ++- .../modell/vergemal/Vergem\303\245lDao.kt" | 37 +------ .../src/test/kotlin/AbstractE2ETest.kt | 2 +- .../test/kotlin/DatabaseIntegrationTest.kt | 11 ++- ...rDaoTest.kt => TxInntektskilderDaoTest.kt} | 6 +- .../arbeidsgiver/ArbeidsgiverDaoTest.kt | 5 +- .../modell/overstyring/OverstyringDaoTest.kt | 6 +- 33 files changed, 586 insertions(+), 536 deletions(-) delete mode 100644 spesialist-selve/src/main/kotlin/no/nav/helse/db/InntektskilderDao.kt create mode 100644 spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalArbeidsforholdDao.kt create mode 100644 spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalAvviksvurderingDao.kt create mode 100644 "spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalP\303\245VentDao.kt" rename spesialist-selve/src/test/kotlin/no/nav/helse/db/{InntektskilderDaoTest.kt => TxInntektskilderDaoTest.kt} (96%) diff --git a/spesialist-felles/src/main/kotlin/no/nav/helse/HelseDao.kt b/spesialist-felles/src/main/kotlin/no/nav/helse/HelseDao.kt index 3a702bb5e..f9f85091d 100644 --- a/spesialist-felles/src/main/kotlin/no/nav/helse/HelseDao.kt +++ b/spesialist-felles/src/main/kotlin/no/nav/helse/HelseDao.kt @@ -2,6 +2,7 @@ package no.nav.helse import kotliquery.Query import kotliquery.Row +import kotliquery.Session import kotliquery.TransactionalSession import kotliquery.queryOf import kotliquery.sessionOf @@ -9,6 +10,31 @@ import org.intellij.lang.annotations.Language import javax.sql.DataSource abstract class HelseDao(private val dataSource: DataSource) { + companion object { + fun asSQL( + @Language("SQL") sql: String, + vararg params: Pair, + ) = queryOf(sql, params.toMap()) + + // Plis bare bruk denne til ting det ikke går an å gjøre med navngitte parametere - eks. ".. AND orgnummer = ANY(?)" + fun asSQLForQuestionMarks( + @Language("SQL") sql: String, + vararg params: Any?, + ) = queryOf(sql, *params) + + fun Query.single( + session: Session, + mapping: (Row) -> T?, + ) = session.run(map(mapping).asSingle) + + fun Query.list( + session: Session, + mapping: (Row) -> T?, + ) = session.run(map(mapping).asList) + + fun Query.update(session: Session) = session.run(asUpdate) + } + fun asSQL( @Language("SQL") sql: String, argMap: Map = emptyMap(), diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingDao.kt index 33ba79c63..1058dfabe 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingDao.kt @@ -1,13 +1,10 @@ package no.nav.helse.db import com.fasterxml.jackson.module.kotlin.readValue -import kotliquery.TransactionalSession import kotliquery.queryOf import kotliquery.sessionOf import no.nav.helse.HelseDao import no.nav.helse.modell.vilkårsprøving.AvviksvurderingDto -import no.nav.helse.modell.vilkårsprøving.BeregningsgrunnlagDto -import no.nav.helse.modell.vilkårsprøving.SammenligningsgrunnlagDto import no.nav.helse.objectMapper import no.nav.helse.spesialist.api.avviksvurdering.Beregningsgrunnlag import no.nav.helse.spesialist.api.avviksvurdering.Sammenligningsgrunnlag @@ -17,7 +14,7 @@ import java.util.UUID import javax.sql.DataSource import no.nav.helse.spesialist.api.avviksvurdering.Avviksvurdering as ApiAvviksvurdering -class AvviksvurderingDao(private val dataSource: DataSource) : HelseDao(dataSource), AvviksvurderingRepository { +class AvviksvurderingDao(private val dataSource: DataSource) : HelseDao(dataSource) { internal fun lagre(avviksvurdering: AvviksvurderingDto) { sessionOf(dataSource, returnGeneratedKey = true).use { session -> @Language("PostgreSQL") @@ -84,55 +81,11 @@ class AvviksvurderingDao(private val dataSource: DataSource) : HelseDao(dataSour } } - internal fun finnAvviksvurderinger(fødselsnummer: String): List = - asSQL( - """ - SELECT av.unik_id, vpa.vilkårsgrunnlag_id, av.fødselsnummer, av.skjæringstidspunkt, av.opprettet, avviksprosent, beregningsgrunnlag, sg.sammenligningsgrunnlag FROM avviksvurdering av - INNER JOIN sammenligningsgrunnlag sg ON av.sammenligningsgrunnlag_ref = sg.id - INNER JOIN vilkarsgrunnlag_per_avviksvurdering vpa ON vpa.avviksvurdering_ref = av.unik_id - WHERE av.fødselsnummer = :fodselsnummer - AND av.slettet IS NULL; - """.trimIndent(), - mapOf( - "fodselsnummer" to fødselsnummer, - ), - ).list { - AvviksvurderingDto( - unikId = it.uuid("unik_id"), - vilkårsgrunnlagId = it.uuid("vilkårsgrunnlag_id"), - fødselsnummer = it.string("fødselsnummer"), - skjæringstidspunkt = it.localDate("skjæringstidspunkt"), - opprettet = it.localDateTime("opprettet"), - avviksprosent = it.double("avviksprosent"), - sammenligningsgrunnlag = objectMapper.readValue(it.string("sammenligningsgrunnlag")), - beregningsgrunnlag = objectMapper.readValue(it.string("beregningsgrunnlag")), - ) - } - - internal fun TransactionalSession.finnAvviksvurderinger(fødselsnummer: String): List = - asSQL( - """ - SELECT av.unik_id, vpa.vilkårsgrunnlag_id, av.fødselsnummer, av.skjæringstidspunkt, av.opprettet, avviksprosent, beregningsgrunnlag, sg.sammenligningsgrunnlag FROM avviksvurdering av - INNER JOIN sammenligningsgrunnlag sg ON av.sammenligningsgrunnlag_ref = sg.id - INNER JOIN vilkarsgrunnlag_per_avviksvurdering vpa ON vpa.avviksvurdering_ref = av.unik_id - WHERE av.fødselsnummer = :fodselsnummer - AND av.slettet IS NULL; - """.trimIndent(), - mapOf( - "fodselsnummer" to fødselsnummer, - ), - ).list(this) { - AvviksvurderingDto( - unikId = it.uuid("unik_id"), - vilkårsgrunnlagId = it.uuid("vilkårsgrunnlag_id"), - fødselsnummer = it.string("fødselsnummer"), - skjæringstidspunkt = it.localDate("skjæringstidspunkt"), - opprettet = it.localDateTime("opprettet"), - avviksprosent = it.double("avviksprosent"), - sammenligningsgrunnlag = objectMapper.readValue(it.string("sammenligningsgrunnlag")), - beregningsgrunnlag = objectMapper.readValue(it.string("beregningsgrunnlag")), - ) + fun finnAvviksvurderinger(fødselsnummer: String): List { + sessionOf(dataSource).use { session -> + return TransactionalAvviksvurderingDao(session).finnAvviksvurderinger(fødselsnummer) } + } internal fun finnAvviksvurdering(vilkårsgrunnlagId: UUID): ApiAvviksvurdering? = asSQL( @@ -161,21 +114,14 @@ class AvviksvurderingDao(private val dataSource: DataSource) : HelseDao(dataSour ) } - override fun opprettKobling( + fun opprettKobling( avviksvurderingId: UUID, vilkårsgrunnlagId: UUID, ) { try { - asSQL( - """ - INSERT INTO vilkarsgrunnlag_per_avviksvurdering(avviksvurdering_ref, vilkårsgrunnlag_id) - VALUES (:unik_id, :vilkarsgrunnlag_id) ON CONFLICT DO NOTHING; - """.trimIndent(), - mapOf( - "unik_id" to avviksvurderingId, - "vilkarsgrunnlag_id" to vilkårsgrunnlagId, - ), - ).update() + sessionOf(dataSource).use { session -> + TransactionalAvviksvurderingDao(session).opprettKobling(avviksvurderingId, vilkårsgrunnlagId) + } } catch (e: Exception) { logg.error("Lagrer IKKE kobling mellom avviksvurdering ($avviksvurderingId) og vilkårsgrunnlag ($vilkårsgrunnlagId)", e) } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingRepository.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingRepository.kt index 3adb02684..4e267291f 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingRepository.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/AvviksvurderingRepository.kt @@ -1,5 +1,6 @@ package no.nav.helse.db +import no.nav.helse.modell.vilkårsprøving.AvviksvurderingDto import java.util.UUID interface AvviksvurderingRepository { @@ -7,4 +8,6 @@ interface AvviksvurderingRepository { avviksvurderingId: UUID, vilkårsgrunnlagId: UUID, ) + + fun finnAvviksvurderinger(fødselsnummer: String): List } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/InntektskilderDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/InntektskilderDao.kt deleted file mode 100644 index 6018de57f..000000000 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/InntektskilderDao.kt +++ /dev/null @@ -1,79 +0,0 @@ -package no.nav.helse.db - -import kotliquery.sessionOf -import no.nav.helse.HelseDao -import no.nav.helse.modell.InntektskildeDto -import no.nav.helse.modell.InntektskildetypeDto -import no.nav.helse.modell.KomplettInntektskildeDto -import no.nav.helse.modell.NyInntektskildeDto -import javax.sql.DataSource - -internal class InntektskilderDao( - private val dataSource: DataSource, -) : HelseDao(dataSource), - InntektskilderRepository { - private val avviksvurderingDao = AvviksvurderingDao(dataSource) - - override fun lagreInntektskilder(inntektskilder: List) { - sessionOf(dataSource, returnGeneratedKey = true).use { session -> - TransactionalInntektskilderDao(session).lagreInntektskilder(inntektskilder) - } - } - - override fun inntektskildeEksisterer(orgnummer: String): Boolean = throw UnsupportedOperationException() - - override fun finnInntektskilder( - fødselsnummer: String, - andreOrganisasjonsnumre: List, - ): List { - val alleOrganisasjonsnumre = - andreOrganisasjonsnumre + organisasjonsnumreFraSammenligningsgrunnlag(fødselsnummer).distinct() - val eksisterendeInntektskilder = eksisterendeInntektskilder(alleOrganisasjonsnumre) - val nyeInntektskilder = andreOrganisasjonsnumre.organisasjonsnumreSomIkkeFinnesI(eksisterendeInntektskilder) - return eksisterendeInntektskilder + nyeInntektskilder - } - - private fun List.organisasjonsnumreSomIkkeFinnesI(inntektskilder: List) = - filterNot { organisasjonsnummer -> organisasjonsnummer in inntektskilder.map { it.organisasjonsnummer } } - .map { NyInntektskildeDto(it, inntektskildetype(it)) } - - private fun eksisterendeInntektskilder(organisasjonsnumre: List): List { - if (organisasjonsnumre.isEmpty()) return emptyList() - return asSQL( - """ - SELECT orgnummer, navn, bransjer, an.navn_oppdatert FROM arbeidsgiver ag - INNER JOIN arbeidsgiver_navn an on an.id = ag.navn_ref - LEFT JOIN arbeidsgiver_bransjer ab on ab.id = ag.bransjer_ref - WHERE orgnummer IN (${organisasjonsnumre.joinToString { "?" }}) - """, - *organisasjonsnumre.map { it.toLong() }.toTypedArray(), - ).list { - val organisasjonsnummer = it.string("orgnummer") - KomplettInntektskildeDto( - organisasjonsnummer = organisasjonsnummer, - type = inntektskildetype(organisasjonsnummer), - navn = it.string("navn"), - bransjer = - it - .stringOrNull("bransjer") - ?.removeSurrounding("[", "]") - ?.replace("\"", "") - ?.split(",") - ?.toList() ?: emptyList(), - sistOppdatert = it.localDate("navn_oppdatert"), - ) - } - } - - private fun organisasjonsnumreFraSammenligningsgrunnlag(fødselsnummer: String): List = - avviksvurderingDao - .finnAvviksvurderinger(fødselsnummer) - .flatMap { it.sammenligningsgrunnlag.innrapporterteInntekter } - .map { it.arbeidsgiverreferanse } - - private fun inntektskildetype(organisasjonsnummer: String): InntektskildetypeDto = - when { - organisasjonsnummer.length == 9 -> InntektskildetypeDto.ORDINÆR - else -> InntektskildetypeDto.ENKELTPERSONFORETAK - } -} diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalArbeidsforholdDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalArbeidsforholdDao.kt new file mode 100644 index 000000000..6b09833ed --- /dev/null +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalArbeidsforholdDao.kt @@ -0,0 +1,98 @@ +package no.nav.helse.db + +import kotliquery.Session +import kotliquery.queryOf +import no.nav.helse.modell.KomplettArbeidsforholdDto +import org.intellij.lang.annotations.Language + +internal class TransactionalArbeidsforholdDao( + private val session: Session, +) : ArbeidsforholdRepository { + override fun findArbeidsforhold( + fødselsnummer: String, + organisasjonsnummer: String, + ): List { + @Language("PostgreSQL") + val query = """ + SELECT startdato, sluttdato, stillingstittel, stillingsprosent + FROM arbeidsforhold + WHERE person_ref = (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer) + AND arbeidsgiver_ref = (SELECT id FROM arbeidsgiver WHERE orgnummer = :organisasjonsnummer); + """ + return session.run( + queryOf( + query, + mapOf( + "fodselsnummer" to fødselsnummer.toLong(), + "organisasjonsnummer" to organisasjonsnummer.toLong(), + ), + ).map { row -> + KomplettArbeidsforholdDto( + fødselsnummer = fødselsnummer, + organisasjonsnummer = organisasjonsnummer, + startdato = row.localDate("startdato"), + sluttdato = row.localDateOrNull("sluttdato"), + stillingsprosent = row.int("stillingsprosent"), + stillingstittel = row.string("stillingstittel"), + ) + }.asList, + ) + } + + override fun upsertArbeidsforhold( + fødselsnummer: String, + organisasjonsnummer: String, + arbeidsforhold: List, + ) { + slettArbeidsforhold(fødselsnummer, organisasjonsnummer) + arbeidsforhold.forEach { komplettArbeidsforhold -> + TransactionalArbeidsforholdDao(session).insertArbeidsforhold(komplettArbeidsforhold) + } + } + + internal fun insertArbeidsforhold(arbeidsforholdDto: KomplettArbeidsforholdDto) { + @Language("PostgreSQL") + val query = """ + INSERT INTO arbeidsforhold(person_ref, arbeidsgiver_ref, startdato, sluttdato, stillingstittel, stillingsprosent) + VALUES( + (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer), + (SELECT id FROM arbeidsgiver WHERE orgnummer = :organisasjonsnummer), + :startdato, :sluttdato, :stillingstittel, :stillingsprosent + ); + """ + session.run( + queryOf( + query, + mapOf( + "fodselsnummer" to arbeidsforholdDto.fødselsnummer.toLong(), + "organisasjonsnummer" to arbeidsforholdDto.organisasjonsnummer.toLong(), + "startdato" to arbeidsforholdDto.startdato, + "sluttdato" to arbeidsforholdDto.sluttdato, + "stillingstittel" to arbeidsforholdDto.stillingstittel, + "stillingsprosent" to arbeidsforholdDto.stillingsprosent, + ), + ).asUpdate, + ) + } + + internal fun slettArbeidsforhold( + fødselsnummer: String, + organisasjonsnummer: String, + ) { + @Language("PostgreSQL") + val deleteQuery = """ + DELETE FROM arbeidsforhold + WHERE person_ref = (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer) + AND arbeidsgiver_ref = (SELECT id FROM arbeidsgiver WHERE orgnummer = :organisasjonsnummer); + """ + session.run( + queryOf( + deleteQuery, + mapOf( + "fodselsnummer" to fødselsnummer.toLong(), + "organisasjonsnummer" to organisasjonsnummer.toLong(), + ), + ).asUpdate, + ) + } +} diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalAvviksvurderingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalAvviksvurderingDao.kt new file mode 100644 index 000000000..a5c0f55e1 --- /dev/null +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalAvviksvurderingDao.kt @@ -0,0 +1,53 @@ +package no.nav.helse.db + +import com.fasterxml.jackson.module.kotlin.readValue +import kotliquery.Session +import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.list +import no.nav.helse.modell.vilkårsprøving.AvviksvurderingDto +import no.nav.helse.modell.vilkårsprøving.BeregningsgrunnlagDto +import no.nav.helse.modell.vilkårsprøving.SammenligningsgrunnlagDto +import no.nav.helse.objectMapper +import org.intellij.lang.annotations.Language +import java.util.UUID + +internal class TransactionalAvviksvurderingDao(private val session: Session) : AvviksvurderingRepository { + override fun opprettKobling( + avviksvurderingId: UUID, + vilkårsgrunnlagId: UUID, + ) { + @Language("PostgreSQL") + val statement = + """ + INSERT INTO vilkarsgrunnlag_per_avviksvurdering(avviksvurdering_ref, vilkårsgrunnlag_id) + VALUES (:unik_id, :vilkarsgrunnlag_id) ON CONFLICT DO NOTHING; + """.trimIndent() + session.run( + queryOf(statement, mapOf("unik_id" to avviksvurderingId, "vilkarsgrunnlag_id" to vilkårsgrunnlagId)).asUpdate, + ) + } + + override fun finnAvviksvurderinger(fødselsnummer: String): List = + asSQL( + """ + SELECT av.unik_id, vpa.vilkårsgrunnlag_id, av.fødselsnummer, av.skjæringstidspunkt, av.opprettet, avviksprosent, beregningsgrunnlag, sg.sammenligningsgrunnlag FROM avviksvurdering av + INNER JOIN sammenligningsgrunnlag sg ON av.sammenligningsgrunnlag_ref = sg.id + INNER JOIN vilkarsgrunnlag_per_avviksvurdering vpa ON vpa.avviksvurdering_ref = av.unik_id + WHERE av.fødselsnummer = :fodselsnummer + AND av.slettet IS NULL; + """.trimIndent(), + "fodselsnummer" to fødselsnummer, + ).list(session) { + AvviksvurderingDto( + unikId = it.uuid("unik_id"), + vilkårsgrunnlagId = it.uuid("vilkårsgrunnlag_id"), + fødselsnummer = it.string("fødselsnummer"), + skjæringstidspunkt = it.localDate("skjæringstidspunkt"), + opprettet = it.localDateTime("opprettet"), + avviksprosent = it.double("avviksprosent"), + sammenligningsgrunnlag = objectMapper.readValue(it.string("sammenligningsgrunnlag")), + beregningsgrunnlag = objectMapper.readValue(it.string("beregningsgrunnlag")), + ) + } +} diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalInntektskilderDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalInntektskilderDao.kt index 418bb4a8f..9aa838a97 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalInntektskilderDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalInntektskilderDao.kt @@ -1,13 +1,18 @@ package no.nav.helse.db import kotliquery.Session +import no.nav.helse.HelseDao.Companion.asSQLForQuestionMarks +import no.nav.helse.HelseDao.Companion.list import no.nav.helse.modell.InntektskildeDto +import no.nav.helse.modell.InntektskildetypeDto import no.nav.helse.modell.KomplettInntektskildeDto +import no.nav.helse.modell.NyInntektskildeDto internal class TransactionalInntektskilderDao( - session: Session, + private val session: Session, ) : InntektskilderRepository { private val arbeidsgiverDao = TransactionalArbeidsgiverDao(session) + private val avviksvurderingDao = TransactionalAvviksvurderingDao(session) override fun lagreInntektskilder(inntektskilder: List) { inntektskilder.forEach { inntekt -> @@ -29,5 +34,55 @@ internal class TransactionalInntektskilderDao( override fun finnInntektskilder( fødselsnummer: String, andreOrganisasjonsnumre: List, - ): List = throw UnsupportedOperationException() + ): List { + val alleOrganisasjonsnumre = + andreOrganisasjonsnumre + organisasjonsnumreFraSammenligningsgrunnlag(fødselsnummer).distinct() + val eksisterendeInntektskilder = eksisterendeInntektskilder(alleOrganisasjonsnumre) + val nyeInntektskilder = andreOrganisasjonsnumre.organisasjonsnumreSomIkkeFinnesI(eksisterendeInntektskilder) + return eksisterendeInntektskilder + nyeInntektskilder + } + + private fun List.organisasjonsnumreSomIkkeFinnesI(inntektskilder: List) = + filterNot { organisasjonsnummer -> organisasjonsnummer in inntektskilder.map { it.organisasjonsnummer } } + .map { NyInntektskildeDto(it, inntektskildetype(it)) } + + private fun eksisterendeInntektskilder(organisasjonsnumre: List): List { + if (organisasjonsnumre.isEmpty()) return emptyList() + return asSQLForQuestionMarks( + """ + SELECT orgnummer, navn, bransjer, an.navn_oppdatert FROM arbeidsgiver ag + INNER JOIN arbeidsgiver_navn an on an.id = ag.navn_ref + LEFT JOIN arbeidsgiver_bransjer ab on ab.id = ag.bransjer_ref + WHERE orgnummer = ANY (?) + """, + organisasjonsnumre.map { it.toLong() }.toTypedArray(), + ).list(session) { + val organisasjonsnummer = it.string("orgnummer") + KomplettInntektskildeDto( + organisasjonsnummer = organisasjonsnummer, + type = inntektskildetype(organisasjonsnummer), + navn = it.string("navn"), + bransjer = + it + .stringOrNull("bransjer") + ?.removeSurrounding("[", "]") + ?.replace("\"", "") + ?.split(",") + ?.toList() ?: emptyList(), + sistOppdatert = it.localDate("navn_oppdatert"), + ) + } + } + + private fun organisasjonsnumreFraSammenligningsgrunnlag(fødselsnummer: String): List = + avviksvurderingDao + .finnAvviksvurderinger(fødselsnummer) + .flatMap { it.sammenligningsgrunnlag.innrapporterteInntekter } + .map { it.arbeidsgiverreferanse } + + private fun inntektskildetype(organisasjonsnummer: String): InntektskildetypeDto = + when { + organisasjonsnummer.length == 9 -> InntektskildetypeDto.ORDINÆR + else -> InntektskildetypeDto.ENKELTPERSONFORETAK + } } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOppgaveDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOppgaveDao.kt index 22b0b2932..42a0b817a 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOppgaveDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOppgaveDao.kt @@ -2,6 +2,8 @@ package no.nav.helse.db import kotliquery.Session import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.single import no.nav.helse.modell.gosysoppgaver.OppgaveDataForAutomatisering import no.nav.helse.modell.oppgave.Egenskap import no.nav.helse.objectMapper @@ -157,7 +159,16 @@ class TransactionalOppgaveDao(private val session: Session) : OppgaveRepository ) } - override fun harGyldigOppgave(utbetalingId: UUID): Boolean = throw UnsupportedOperationException() + override fun harGyldigOppgave(utbetalingId: UUID) = + requireNotNull( + asSQL( + """ + SELECT COUNT(1) AS oppgave_count FROM oppgave + WHERE utbetaling_id = :utbetalingId AND status IN('AvventerSystem'::oppgavestatus, 'AvventerSaksbehandler'::oppgavestatus, 'Ferdigstilt'::oppgavestatus) + """.trimIndent(), + "utbetalingId" to utbetalingId, + ).single(session) { it.int("oppgave_count") }, + ) > 0 override fun finnHendelseId(id: Long): UUID { @Language("PostgreSQL") diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOverstyringDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOverstyringDao.kt index d98d86ea1..00231ce61 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOverstyringDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalOverstyringDao.kt @@ -2,6 +2,9 @@ package no.nav.helse.db import kotliquery.Session import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.asSQLForQuestionMarks +import no.nav.helse.HelseDao.Companion.list import no.nav.helse.spesialist.api.overstyring.OverstyringType import org.intellij.lang.annotations.Language import java.util.UUID @@ -9,12 +12,54 @@ import java.util.UUID class TransactionalOverstyringDao( private val session: Session, ) : OverstyringRepository { - override fun finnOverstyringerMedTypeForVedtaksperioder(vedtaksperiodeIder: List): List { - throw UnsupportedOperationException() - } + override fun finnOverstyringerMedTypeForVedtaksperioder(vedtaksperiodeIder: List) = + asSQLForQuestionMarks( + """ + SELECT DISTINCT o.id, + CASE + WHEN oi.id IS NOT NULL THEN 'Inntekt' + WHEN oa.id IS NOT NULL THEN 'Arbeidsforhold' + WHEN ot.id IS NOT NULL THEN 'Dager' + WHEN ss.id IS NOT NULL THEN 'Sykepengegrunnlag' + WHEN oms.id IS NOT NULL THEN 'MinimumSykdomsgrad' + END as type + FROM overstyring o + LEFT JOIN overstyring_arbeidsforhold oa on o.id = oa.overstyring_ref + LEFT JOIN overstyring_inntekt oi on o.id = oi.overstyring_ref + LEFT JOIN overstyring_tidslinje ot on o.id = ot.overstyring_ref + LEFT JOIN skjonnsfastsetting_sykepengegrunnlag ss on o.id = ss.overstyring_ref + LEFT JOIN overstyring_minimum_sykdomsgrad oms on o.id = oms.overstyring_ref + WHERE o.vedtaksperiode_id IN (${vedtaksperiodeIder.joinToString { "?" }}) + AND o.ferdigstilt = false + """.trimIndent(), + *vedtaksperiodeIder.toTypedArray(), + ).list(session) { OverstyringType.valueOf(it.string("type")) } override fun finnOverstyringerMedTypeForVedtaksperiode(vedtaksperiodeId: UUID): List { - throw UnsupportedOperationException() + return asSQL( + """ + SELECT DISTINCT o.id, + CASE + WHEN oi.id IS NOT NULL THEN 'Inntekt' + WHEN oa.id IS NOT NULL THEN 'Arbeidsforhold' + WHEN ot.id IS NOT NULL THEN 'Dager' + WHEN ss.id IS NOT NULL THEN 'Sykepengegrunnlag' + WHEN oms.id IS NOT NULL THEN 'MinimumSykdomsgrad' + END as type + FROM overstyring o + LEFT JOIN overstyring_arbeidsforhold oa on o.id = oa.overstyring_ref + LEFT JOIN overstyring_inntekt oi on o.id = oi.overstyring_ref + LEFT JOIN overstyring_tidslinje ot on o.id = ot.overstyring_ref + LEFT JOIN skjonnsfastsetting_sykepengegrunnlag ss on o.id = ss.overstyring_ref + LEFT JOIN overstyring_minimum_sykdomsgrad oms on o.id = oms.overstyring_ref + WHERE o.id IN ( + SELECT overstyring_ref FROM overstyringer_for_vedtaksperioder + WHERE vedtaksperiode_id = :vedtaksperiodeId + ) + AND o.ferdigstilt = false + """.trimIndent(), + "vedtaksperiodeId" to vedtaksperiodeId, + ).list(session) { OverstyringType.valueOf(it.string("type")) } } override fun finnesEksternHendelseId(eksternHendelseId: UUID): Boolean { diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalPersonDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalPersonDao.kt index ed411a4a4..7fe82befa 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalPersonDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalPersonDao.kt @@ -1,8 +1,12 @@ package no.nav.helse.db import com.fasterxml.jackson.databind.JsonNode +import com.fasterxml.jackson.module.kotlin.readValue import kotliquery.Session import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.single +import no.nav.helse.HelseDao.Companion.update import no.nav.helse.mediator.meldinger.løsninger.Inntekter import no.nav.helse.modell.kommando.MinimalPersonDto import no.nav.helse.modell.person.PersonDto @@ -59,7 +63,11 @@ internal class TransactionalPersonDao( ) } - override fun finnITUtbetalingsperioderSistOppdatert(fødselsnummer: String): LocalDate = throw UnsupportedOperationException() + override fun finnITUtbetalingsperioderSistOppdatert(fødselsnummer: String) = + asSQL( + "SELECT infotrygdutbetalinger_oppdatert FROM person WHERE fodselsnummer = :foedselsnummer", + "foedselsnummer" to fødselsnummer.toLong(), + ).single(session) { it.localDateOrNull("infotrygdutbetalinger_oppdatert") } override fun upsertInfotrygdutbetalinger( fødselsnummer: String, @@ -110,18 +118,38 @@ internal class TransactionalPersonDao( override fun finnInntekter( fødselsnummer: String, skjæringstidspunkt: LocalDate, - ): List? { - throw UnsupportedOperationException() - } + ) = asSQL( + """ + SELECT * FROM inntekt + WHERE person_ref=(SELECT id FROM person WHERE fodselsnummer=:fodselsnummer) + AND skjaeringstidspunkt=:skjaeringstidspunkt; + """.trimIndent(), + "fodselsnummer" to fødselsnummer.toLong(), + "skjaeringstidspunkt" to skjæringstidspunkt, + ).single(session) { objectMapper.readValue>(it.string("inntekter")) } override fun lagreInntekter( fødselsnummer: String, skjæringstidspunkt: LocalDate, inntekter: List, - ): Long? { - throw UnsupportedOperationException() + ) = finnPersonRef(fødselsnummer)?.also { + asSQL( + """ + INSERT INTO inntekt (person_ref, skjaeringstidspunkt, inntekter) + VALUES (:person_ref, :skjaeringstidspunkt, :inntekter::json) + """.trimIndent(), + "person_ref" to it, + "skjaeringstidspunkt" to skjæringstidspunkt, + "inntekter" to objectMapper.writeValueAsString(inntekter), + ).update(session) } + private fun finnPersonRef(fødselsnummer: String) = + asSQL( + "SELECT id FROM person WHERE fodselsnummer = :foedselsnummer", + "foedselsnummer" to fødselsnummer.toLong(), + ).single(session) { it.longOrNull("id") } + override fun finnEnhetId(fødselsnummer: String): String { @Language("PostgreSQL") val statement = "SELECT enhet_ref FROM person where fodselsnummer = ?;" diff --git "a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalP\303\245VentDao.kt" "b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalP\303\245VentDao.kt" new file mode 100644 index 000000000..dac0d2c09 --- /dev/null +++ "b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalP\303\245VentDao.kt" @@ -0,0 +1,22 @@ +package no.nav.helse.db + +import kotliquery.Session +import kotliquery.queryOf +import org.intellij.lang.annotations.Language +import java.util.UUID + +internal class TransactionalPåVentDao(private val session: Session) : PåVentRepository { + override fun erPåVent(vedtaksperiodeId: UUID): Boolean { + @Language("PostgreSQL") + val statement = + """ + SELECT 1 FROM pa_vent WHERE vedtaksperiode_id = :vedtaksperiodeId + """.trimIndent() + return session.run( + queryOf( + statement, + mapOf("vedtaksperiodeId" to vedtaksperiodeId), + ).map { it.boolean(1) }.asSingle, + ) ?: false + } +} diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalRisikovurderingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalRisikovurderingDao.kt index d522b2f97..35f439c88 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalRisikovurderingDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalRisikovurderingDao.kt @@ -3,7 +3,11 @@ package no.nav.helse.db import com.fasterxml.jackson.databind.JsonNode import kotliquery.Session import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.single +import no.nav.helse.HelseDao.Companion.update import no.nav.helse.modell.risiko.Risikovurdering +import no.nav.helse.objectMapper import org.intellij.lang.annotations.Language import java.time.LocalDateTime import java.util.UUID @@ -22,7 +26,17 @@ class TransactionalRisikovurderingDao(private val session: Session) : Risikovurd )?.let(Risikovurdering::restore) } - override fun kreverSupersaksbehandler(vedtaksperiodeId: UUID): Boolean = throw UnsupportedOperationException() + override fun kreverSupersaksbehandler(vedtaksperiodeId: UUID) = + asSQL( + """ + SELECT krever_supersaksbehandler + FROM risikovurdering_2021 + WHERE vedtaksperiode_id = :vedtaksperiodeId + ORDER BY id DESC + LIMIT 1 + """.trimIndent(), + "vedtaksperiodeId" to vedtaksperiodeId, + ).single(session) { it.boolean("krever_supersaksbehandler") } ?: false override fun lagre( vedtaksperiodeId: UUID, @@ -31,6 +45,16 @@ class TransactionalRisikovurderingDao(private val session: Session) : Risikovurd data: JsonNode, opprettet: LocalDateTime, ) { - throw UnsupportedOperationException() + asSQL( + """ + INSERT INTO risikovurdering_2021 (vedtaksperiode_id, kan_godkjennes_automatisk, krever_supersaksbehandler, data, opprettet) + VALUES (:vedtaksperiodeId, :kanGodkjennesAutomatisk, :kreverSupersaksbehandler, CAST (:data AS JSON), :opprettet); + """.trimIndent(), + "vedtaksperiodeId" to vedtaksperiodeId, + "kanGodkjennesAutomatisk" to kanGodkjennesAutomatisk, + "kreverSupersaksbehandler" to kreverSupersaksbehandler, + "data" to objectMapper.writeValueAsString(data), + "opprettet" to opprettet, + ).update(session) } } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalTotrinnsvurderingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalTotrinnsvurderingDao.kt index 10cff5873..42c3a2e8d 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalTotrinnsvurderingDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalTotrinnsvurderingDao.kt @@ -127,16 +127,17 @@ internal class TransactionalTotrinnsvurderingDao( """ INSERT INTO totrinnsvurdering (vedtaksperiode_id) VALUES (:vedtaksperiodeId) - RETURNING * """.trimIndent() - return requireNotNull( - session.run( - queryOf( - query, - mapOf("vedtaksperiodeId" to vedtaksperiodeId), - ).tilTotrinnsvurdering(), - ), - ) + session.run(queryOf(query, mapOf("vedtaksperiodeId" to vedtaksperiodeId)).asUpdate) + @Language("PostgreSQL") + val selectQuery = + """ + SELECT * FROM totrinnsvurdering + WHERE vedtaksperiode_id = :vedtaksperiodeId + """.trimIndent() + val totrinnsvurdering = session.run(queryOf(selectQuery, mapOf("vedtaksperiodeId" to vedtaksperiodeId)).tilTotrinnsvurdering()) + + return requireNotNull(totrinnsvurdering) } override fun hentAktiv(oppgaveId: Long): TotrinnsvurderingOld? { diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalUtbetalingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalUtbetalingDao.kt index c5beb61b5..cad9347d6 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalUtbetalingDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalUtbetalingDao.kt @@ -193,5 +193,18 @@ class TransactionalUtbetalingDao(private val session: Session) : UtbetalingRepos ) } - override fun erUtbetalingForkastet(utbetalingId: UUID): Boolean = throw UnsupportedOperationException() + override fun erUtbetalingForkastet(utbetalingId: UUID): Boolean { + @Language("PostgreSQL") + val query = + """ + SELECT 1 + FROM utbetaling u + JOIN utbetaling_id ui ON u.utbetaling_id_ref = ui.id + WHERE ui.utbetaling_id = :utbetaling_id + AND status = 'FORKASTET' + """.trimIndent() + return session.run( + queryOf(query, mapOf("utbetaling_id" to utbetalingId)).map { true }.asSingle, + ) ?: false + } } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVedtakDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVedtakDao.kt index 4b3afda7c..b91115c24 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVedtakDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVedtakDao.kt @@ -2,6 +2,9 @@ package no.nav.helse.db import kotliquery.Session import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.single +import no.nav.helse.HelseDao.Companion.update import no.nav.helse.modell.vedtaksperiode.Inntektskilde import no.nav.helse.modell.vedtaksperiode.Periodetype import org.intellij.lang.annotations.Language @@ -12,7 +15,23 @@ class TransactionalVedtakDao(private val session: Session) : VedtakRepository { vedtaksperiodeId: UUID, type: Periodetype, inntektskilde: Inntektskilde, - ) = throw UnsupportedOperationException() + ) { + val vedtakRef = finnVedtakId(vedtaksperiodeId) ?: return + asSQL( + """ + INSERT INTO saksbehandleroppgavetype (type, inntektskilde, vedtak_ref) VALUES (:type, :inntektskilde, :vedtak_ref) + ON CONFLICT (vedtak_ref) DO UPDATE SET type = :type, inntektskilde = :inntektskilde + """.trimIndent(), + "type" to type.name, + "inntektskilde" to inntektskilde.name, + "vedtak_ref" to vedtakRef, + ).update(session) + } + + internal fun finnVedtakId(vedtaksperiodeId: UUID) = + asSQL("SELECT id FROM vedtak WHERE vedtaksperiode_id = :vedtaksperiodeId", "vedtaksperiodeId" to vedtaksperiodeId).single(session) { + it.long("id") + } override fun erSpesialsak(vedtaksperiodeId: UUID): Boolean { @Language("PostgreSQL") @@ -24,7 +43,19 @@ class TransactionalVedtakDao(private val session: Session) : VedtakRepository { ) ?: false } - override fun erAutomatiskGodkjent(utbetalingId: UUID): Boolean = throw UnsupportedOperationException() + override fun erAutomatiskGodkjent(utbetalingId: UUID) = + asSQL( + """ + SELECT automatisert FROM automatisering + WHERE utbetaling_id = :utbetalingId + AND (inaktiv_fra IS NULL OR inaktiv_fra > now()) + ORDER BY id DESC + LIMIT 1 + """.trimIndent(), + "utbetalingId" to utbetalingId, + ).single(session) { + it.boolean("automatisert") + } ?: false override fun opprettKobling( vedtaksperiodeId: UUID, diff --git "a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVergem\303\245lDao.kt" "b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVergem\303\245lDao.kt" index 2cd444dd9..a5b00048e 100644 --- "a/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVergem\303\245lDao.kt" +++ "b/spesialist-selve/src/main/kotlin/no/nav/helse/db/TransactionalVergem\303\245lDao.kt" @@ -2,8 +2,11 @@ package no.nav.helse.db import kotliquery.Session import kotliquery.queryOf +import no.nav.helse.HelseDao.Companion.asSQL +import no.nav.helse.HelseDao.Companion.update import no.nav.helse.modell.vergemal.VergemålOgFremtidsfullmakt import org.intellij.lang.annotations.Language +import java.time.LocalDateTime class TransactionalVergemålDao(private val session: Session) : VergemålRepository { override fun lagre( @@ -11,7 +14,31 @@ class TransactionalVergemålDao(private val session: Session) : VergemålReposit vergemålOgFremtidsfullmakt: VergemålOgFremtidsfullmakt, fullmakt: Boolean, ) { - throw UnsupportedOperationException() + asSQL( + """ + INSERT INTO vergemal (person_ref, har_vergemal, har_fremtidsfullmakter, har_fullmakter, vergemål_oppdatert, fullmakt_oppdatert) + VALUES ( + (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer), + :har_vergemal, + :har_fremtidsfullmakter, + :har_fullmakter, + :oppdatert, + :oppdatert + ) + ON CONFLICT (person_ref) + DO UPDATE SET + har_vergemal = :har_vergemal, + har_fremtidsfullmakter = :har_fremtidsfullmakter, + har_fullmakter = :har_fullmakter, + vergemål_oppdatert = :oppdatert, + fullmakt_oppdatert = :oppdatert + """.trimIndent(), + "fodselsnummer" to fødselsnummer.toLong(), + "har_vergemal" to vergemålOgFremtidsfullmakt.harVergemål, + "har_fremtidsfullmakter" to vergemålOgFremtidsfullmakt.harFremtidsfullmakter, + "har_fullmakter" to fullmakt, + "oppdatert" to LocalDateTime.now(), + ).update(session) } override fun harVergemål(fødselsnummer: String): Boolean? { diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/Kommandofabrikk.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/Kommandofabrikk.kt index 625a578e7..22781f6d7 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/Kommandofabrikk.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/Kommandofabrikk.kt @@ -4,10 +4,9 @@ import kotliquery.TransactionalSession import kotliquery.sessionOf import no.nav.helse.db.AvviksvurderingDao import no.nav.helse.db.CommandContextRepository -import no.nav.helse.db.InntektskilderDao import no.nav.helse.db.OppgaveRepository -import no.nav.helse.db.PgHistorikkinnslagRepository -import no.nav.helse.db.TotrinnsvurderingDao +import no.nav.helse.db.TransactionalArbeidsforholdDao +import no.nav.helse.db.TransactionalAvviksvurderingDao import no.nav.helse.db.TransactionalCommandContextDao import no.nav.helse.db.TransactionalEgenAnsattDao import no.nav.helse.db.TransactionalInntektskilderDao @@ -17,10 +16,14 @@ import no.nav.helse.db.TransactionalOpptegnelseDao import no.nav.helse.db.TransactionalOverstyringDao import no.nav.helse.db.TransactionalPeriodehistorikkDao import no.nav.helse.db.TransactionalPersonDao +import no.nav.helse.db.TransactionalPåVentDao import no.nav.helse.db.TransactionalReservasjonDao +import no.nav.helse.db.TransactionalRisikovurderingDao import no.nav.helse.db.TransactionalTildelingDao import no.nav.helse.db.TransactionalTotrinnsvurderingDao import no.nav.helse.db.TransactionalUtbetalingDao +import no.nav.helse.db.TransactionalVedtakDao +import no.nav.helse.db.TransactionalVergemålDao import no.nav.helse.db.TransactionalÅpneGosysOppgaverDao import no.nav.helse.mediator.meldinger.AdressebeskyttelseEndret import no.nav.helse.mediator.meldinger.AdressebeskyttelseEndretCommand @@ -29,31 +32,24 @@ import no.nav.helse.mediator.oppgave.OppgaveDao import no.nav.helse.mediator.oppgave.OppgaveService import no.nav.helse.modell.CommandContextDao import no.nav.helse.modell.MeldingDao -import no.nav.helse.modell.VedtakDao -import no.nav.helse.modell.arbeidsforhold.ArbeidsforholdDao import no.nav.helse.modell.automatisering.Automatisering import no.nav.helse.modell.egenansatt.EgenAnsattDao import no.nav.helse.modell.gosysoppgaver.GosysOppgaveEndretCommand import no.nav.helse.modell.gosysoppgaver.OppgaveDataForAutomatisering -import no.nav.helse.modell.gosysoppgaver.ÅpneGosysOppgaverDao import no.nav.helse.modell.kommando.Command import no.nav.helse.modell.kommando.CommandContext import no.nav.helse.modell.kommando.LøsGodkjenningsbehov import no.nav.helse.modell.kommando.OverstyringIgangsattCommand import no.nav.helse.modell.kommando.TilbakedateringBehandlet import no.nav.helse.modell.kommando.TilbakedateringGodkjentCommand -import no.nav.helse.modell.overstyring.OverstyringDao import no.nav.helse.modell.overstyring.OverstyringIgangsatt import no.nav.helse.modell.person.EndretEgenAnsattStatus import no.nav.helse.modell.person.EndretEgenAnsattStatusCommand import no.nav.helse.modell.person.KlargjørTilgangsrelaterteDataCommand import no.nav.helse.modell.person.OppdaterPersondataCommand import no.nav.helse.modell.person.Person -import no.nav.helse.modell.person.PersonDao import no.nav.helse.modell.person.SøknadSendt import no.nav.helse.modell.person.SøknadSendtCommand -import no.nav.helse.modell.påvent.PåVentDao -import no.nav.helse.modell.risiko.RisikovurderingDao import no.nav.helse.modell.totrinnsvurdering.TotrinnsvurderingService import no.nav.helse.modell.utbetaling.UtbetalingDao import no.nav.helse.modell.utbetaling.UtbetalingEndret @@ -69,7 +65,6 @@ import no.nav.helse.modell.vedtaksperiode.VedtaksperiodeNyUtbetalingCommand import no.nav.helse.modell.vedtaksperiode.VedtaksperiodeReberegnet import no.nav.helse.modell.vedtaksperiode.VedtaksperiodeReberegnetCommand import no.nav.helse.modell.vedtaksperiode.vedtak.Saksbehandlerløsning -import no.nav.helse.modell.vergemal.VergemålDao import no.nav.helse.modell.vilkårsprøving.AvviksvurderingDto import no.nav.helse.registrerTidsbrukForGodkjenningsbehov import no.nav.helse.registrerTidsbrukForHendelse @@ -82,30 +77,14 @@ internal typealias Kommandostarter = Personmelding.(Kommandofabrikk.() -> Comman internal class Kommandofabrikk( private val dataSource: DataSource, private val meldingDao: MeldingDao = MeldingDao(dataSource), - private val personDao: PersonDao = PersonDao(dataSource), - private val vedtakDao: VedtakDao = VedtakDao(dataSource), private val oppgaveDao: OppgaveDao = OppgaveDao(dataSource), private val commandContextDao: CommandContextDao = CommandContextDao(dataSource), - private val overstyringDao: OverstyringDao = OverstyringDao(dataSource), - private val risikovurderingDao: RisikovurderingDao = RisikovurderingDao(dataSource), - private val åpneGosysOppgaverDao: ÅpneGosysOppgaverDao = ÅpneGosysOppgaverDao(dataSource), private val egenAnsattDao: EgenAnsattDao = EgenAnsattDao(dataSource), oppgaveService: () -> OppgaveService, - private val totrinnsvurderingDao: TotrinnsvurderingDao = TotrinnsvurderingDao(dataSource), - private val pgHistorikkinnslagRepository: PgHistorikkinnslagRepository = PgHistorikkinnslagRepository(dataSource), - private val påVentDao: PåVentDao = PåVentDao(dataSource), - private val totrinnsvurderingService: TotrinnsvurderingService = - TotrinnsvurderingService( - totrinnsvurderingDao, - oppgaveDao, - pgHistorikkinnslagRepository, - ), private val godkjenningMediator: GodkjenningMediator, private val automatisering: Automatisering, - private val arbeidsforholdDao: ArbeidsforholdDao = ArbeidsforholdDao(dataSource), private val utbetalingDao: UtbetalingDao = UtbetalingDao(dataSource), private val generasjonService: GenerasjonService = GenerasjonService(dataSource), - private val vergemålDao: VergemålDao = VergemålDao(dataSource), ) { private companion object { private val logg = LoggerFactory.getLogger(this::class.java) @@ -139,7 +118,9 @@ internal class Kommandofabrikk( ): GosysOppgaveEndretCommand { val utbetaling = TransactionalUtbetalingDao(transactionalSession).hentUtbetaling(oppgaveDataForAutomatisering.utbetalingId) val harTildeltOppgave = - TransactionalTildelingDao(transactionalSession).tildelingForOppgave(oppgaveDataForAutomatisering.oppgaveId) != null + TransactionalTildelingDao( + transactionalSession, + ).tildelingForOppgave(oppgaveDataForAutomatisering.oppgaveId) != null val godkjenningsbehovData = TransactionalMeldingDao( transactionalSession, @@ -386,6 +367,7 @@ internal class Kommandofabrikk( internal fun godkjenningsbehov( godkjenningsbehovData: GodkjenningsbehovData, person: Person, + session: TransactionalSession, ): GodkjenningsbehovCommand { val utbetaling = utbetalingDao.hentUtbetaling(godkjenningsbehovData.utbetalingId) val førsteKjenteDagFinner = { generasjonService.førsteKjenteDag(godkjenningsbehovData.fødselsnummer) } @@ -393,25 +375,30 @@ internal class Kommandofabrikk( behovData = godkjenningsbehovData, utbetaling = utbetaling, førsteKjenteDagFinner = førsteKjenteDagFinner, - automatisering = automatisering, - vedtakRepository = vedtakDao, - commandContextRepository = commandContextDao, - personRepository = personDao, - inntektskilderRepository = InntektskilderDao(dataSource), - arbeidsforholdRepository = arbeidsforholdDao, - egenAnsattRepository = egenAnsattDao, - utbetalingRepository = utbetalingDao, - vergemålRepository = vergemålDao, - åpneGosysOppgaverRepository = åpneGosysOppgaverDao, - risikovurderingRepository = risikovurderingDao, - påVentRepository = påVentDao, - overstyringRepository = overstyringDao, - periodehistorikkDao = pgHistorikkinnslagRepository, - oppgaveRepository = oppgaveDao, - avviksvurderingRepository = avviksvurderingDao, - oppgaveService = oppgaveService, - godkjenningMediator = godkjenningMediator, - totrinnsvurderingService = totrinnsvurderingService, + automatisering = automatisering.nyAutomatisering(session), + vedtakRepository = TransactionalVedtakDao(session), + commandContextRepository = TransactionalCommandContextDao(session), + personRepository = TransactionalPersonDao(session), + inntektskilderRepository = TransactionalInntektskilderDao(session), + arbeidsforholdRepository = TransactionalArbeidsforholdDao(session), + egenAnsattRepository = TransactionalEgenAnsattDao(session), + utbetalingRepository = TransactionalUtbetalingDao(session), + vergemålRepository = TransactionalVergemålDao(session), + åpneGosysOppgaverRepository = TransactionalÅpneGosysOppgaverDao(session), + risikovurderingRepository = TransactionalRisikovurderingDao(session), + påVentRepository = TransactionalPåVentDao(session), + overstyringRepository = TransactionalOverstyringDao(session), + periodehistorikkDao = TransactionalPeriodehistorikkDao(session), + oppgaveRepository = TransactionalOppgaveDao(session), + avviksvurderingRepository = TransactionalAvviksvurderingDao(session), + oppgaveService = transaksjonellOppgaveService(session), + godkjenningMediator = GodkjenningMediator(TransactionalOpptegnelseDao(session)), + totrinnsvurderingService = + TotrinnsvurderingService( + TransactionalTotrinnsvurderingDao(session), + TransactionalOppgaveDao(session), + TransactionalPeriodehistorikkDao(session), + ), person = person, ) } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveDao.kt index 897cc82db..c50989aab 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/mediator/oppgave/OppgaveDao.kt @@ -163,15 +163,7 @@ class OppgaveDao(private val dataSource: DataSource) : HelseDao(dataSource), Opp TransactionalOppgaveDao(session).finnHendelseId(id) } - override fun harGyldigOppgave(utbetalingId: UUID) = - requireNotNull( - asSQL( - """ SELECT COUNT(1) AS oppgave_count FROM oppgave - WHERE utbetaling_id = :utbetalingId AND status IN('AvventerSystem'::oppgavestatus, 'AvventerSaksbehandler'::oppgavestatus, 'Ferdigstilt'::oppgavestatus) - """, - mapOf("utbetalingId" to utbetalingId), - ).single { it.int("oppgave_count") }, - ) > 0 + override fun harGyldigOppgave(utbetalingId: UUID) = TransactionalOppgaveDao(sessionOf(dataSource)).harGyldigOppgave(utbetalingId) override fun harFerdigstiltOppgave(vedtaksperiodeId: UUID) = sessionOf(dataSource).use { session -> diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/VedtakDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/VedtakDao.kt index 1f8aa17c8..424c632b0 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/VedtakDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/VedtakDao.kt @@ -122,23 +122,7 @@ internal class VedtakDao(private val dataSource: DataSource) : VedtakRepository type: Periodetype, inntektskilde: Inntektskilde, ) = sessionOf(dataSource).use { session -> - val vedtakRef = finnVedtakId(vedtaksperiodeId) ?: return@use - - @Language("PostgreSQL") - val statement = """ - INSERT INTO saksbehandleroppgavetype (type, inntektskilde, vedtak_ref) VALUES (:type, :inntektskilde, :vedtak_ref) - ON CONFLICT (vedtak_ref) DO UPDATE SET type = :type, inntektskilde = :inntektskilde - """ - session.run( - queryOf( - statement, - mapOf( - "type" to type.name, - "inntektskilde" to inntektskilde.name, - "vedtak_ref" to vedtakRef, - ), - ).asUpdate, - ) + TransactionalVedtakDao(session).leggTilVedtaksperiodetype(vedtaksperiodeId, type, inntektskilde) } internal fun finnVedtaksperiodetype(vedtaksperiodeId: UUID): Periodetype = @@ -163,17 +147,7 @@ internal class VedtakDao(private val dataSource: DataSource) : VedtakRepository } override fun erAutomatiskGodkjent(utbetalingId: UUID) = - sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = """ - SELECT automatisert FROM automatisering - WHERE utbetaling_id = ? - AND (inaktiv_fra IS NULL OR inaktiv_fra > now()) - ORDER BY id DESC - LIMIT 1 - """ - session.run(queryOf(query, utbetalingId).map { it.boolean("automatisert") }.asSingle) - } ?: false + sessionOf(dataSource).use { TransactionalVedtakDao(it).erAutomatiskGodkjent(utbetalingId) } override fun finnOrgnummer(vedtaksperiodeId: UUID) = sessionOf(dataSource).use { session -> diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/arbeidsforhold/ArbeidsforholdDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/arbeidsforhold/ArbeidsforholdDao.kt index c3d5a5517..90890a294 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/arbeidsforhold/ArbeidsforholdDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/arbeidsforhold/ArbeidsforholdDao.kt @@ -1,12 +1,9 @@ package no.nav.helse.modell.arbeidsforhold -import kotliquery.Session -import kotliquery.TransactionalSession -import kotliquery.queryOf import kotliquery.sessionOf import no.nav.helse.db.ArbeidsforholdRepository +import no.nav.helse.db.TransactionalArbeidsforholdDao import no.nav.helse.modell.KomplettArbeidsforholdDto -import org.intellij.lang.annotations.Language import javax.sql.DataSource class ArbeidsforholdDao(private val dataSource: DataSource) : ArbeidsforholdRepository { @@ -14,91 +11,16 @@ class ArbeidsforholdDao(private val dataSource: DataSource) : ArbeidsforholdRepo fødselsnummer: String, organisasjonsnummer: String, arbeidsforhold: List, - ) = sessionOf(dataSource, returnGeneratedKey = true).use { session -> - session.transaction { transaction -> - slettArbeidsforhold(transaction, fødselsnummer, organisasjonsnummer) - arbeidsforhold.forEach { komplettArbeidsforhold -> - transaction.insertArbeidsforhold(komplettArbeidsforhold) - } - } + ) = sessionOf(dataSource).use { + TransactionalArbeidsforholdDao(it).upsertArbeidsforhold(fødselsnummer, organisasjonsnummer, arbeidsforhold) } override fun findArbeidsforhold( fødselsnummer: String, organisasjonsnummer: String, - ): List = + ): List { sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = """ - SELECT startdato, sluttdato, stillingstittel, stillingsprosent - FROM arbeidsforhold - WHERE person_ref = (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer) - AND arbeidsgiver_ref = (SELECT id FROM arbeidsgiver WHERE orgnummer = :organisasjonsnummer); - """ - session.run( - queryOf( - query, - mapOf( - "fodselsnummer" to fødselsnummer.toLong(), - "organisasjonsnummer" to organisasjonsnummer.toLong(), - ), - ).map { row -> - KomplettArbeidsforholdDto( - fødselsnummer = fødselsnummer, - organisasjonsnummer = organisasjonsnummer, - startdato = row.localDate("startdato"), - sluttdato = row.localDateOrNull("sluttdato"), - stillingsprosent = row.int("stillingsprosent"), - stillingstittel = row.string("stillingstittel"), - ) - }.asList, - ) + return TransactionalArbeidsforholdDao(session).findArbeidsforhold(fødselsnummer, organisasjonsnummer) } - - private fun Session.insertArbeidsforhold(arbeidsforholdDto: KomplettArbeidsforholdDto) { - @Language("PostgreSQL") - val query = """ - INSERT INTO arbeidsforhold(person_ref, arbeidsgiver_ref, startdato, sluttdato, stillingstittel, stillingsprosent) - VALUES( - (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer), - (SELECT id FROM arbeidsgiver WHERE orgnummer = :organisasjonsnummer), - :startdato, :sluttdato, :stillingstittel, :stillingsprosent - ); - """ - run( - queryOf( - query, - mapOf( - "fodselsnummer" to arbeidsforholdDto.fødselsnummer.toLong(), - "organisasjonsnummer" to arbeidsforholdDto.organisasjonsnummer.toLong(), - "startdato" to arbeidsforholdDto.startdato, - "sluttdato" to arbeidsforholdDto.sluttdato, - "stillingstittel" to arbeidsforholdDto.stillingstittel, - "stillingsprosent" to arbeidsforholdDto.stillingsprosent, - ), - ).asUpdate, - ) - } - - private fun slettArbeidsforhold( - transaction: TransactionalSession, - fødselsnummer: String, - organisasjonsnummer: String, - ) { - @Language("PostgreSQL") - val deleteQuery = """ - DELETE FROM arbeidsforhold - WHERE person_ref = (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer) - AND arbeidsgiver_ref = (SELECT id FROM arbeidsgiver WHERE orgnummer = :organisasjonsnummer); - """ - transaction.run( - queryOf( - deleteQuery, - mapOf( - "fodselsnummer" to fødselsnummer.toLong(), - "organisasjonsnummer" to organisasjonsnummer.toLong(), - ), - ).asUpdate, - ) } } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/overstyring/OverstyringDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/overstyring/OverstyringDao.kt index ef4c6fdb1..1cfe0d111 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/overstyring/OverstyringDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/overstyring/OverstyringDao.kt @@ -17,54 +17,15 @@ import java.util.UUID import javax.sql.DataSource class OverstyringDao(private val dataSource: DataSource) : HelseDao(dataSource), OverstyringRepository { - override fun finnOverstyringerMedTypeForVedtaksperioder(vedtaksperiodeIder: List): List { - return asSQL( - """ SELECT DISTINCT o.id, - CASE - WHEN oi.id IS NOT NULL THEN 'Inntekt' - WHEN oa.id IS NOT NULL THEN 'Arbeidsforhold' - WHEN ot.id IS NOT NULL THEN 'Dager' - WHEN ss.id IS NOT NULL THEN 'Sykepengegrunnlag' - WHEN oms.id IS NOT NULL THEN 'MinimumSykdomsgrad' - END as type - FROM overstyring o - LEFT JOIN overstyring_arbeidsforhold oa on o.id = oa.overstyring_ref - LEFT JOIN overstyring_inntekt oi on o.id = oi.overstyring_ref - LEFT JOIN overstyring_tidslinje ot on o.id = ot.overstyring_ref - LEFT JOIN skjonnsfastsetting_sykepengegrunnlag ss on o.id = ss.overstyring_ref - LEFT JOIN overstyring_minimum_sykdomsgrad oms on o.id = oms.overstyring_ref - WHERE o.vedtaksperiode_id IN (${vedtaksperiodeIder.joinToString { "?" }}) - AND o.ferdigstilt = false - """, - *vedtaksperiodeIder.toTypedArray(), - ).list { OverstyringType.valueOf(it.string("type")) } - } + override fun finnOverstyringerMedTypeForVedtaksperioder(vedtaksperiodeIder: List): List = + sessionOf(dataSource).use { + TransactionalOverstyringDao(it).finnOverstyringerMedTypeForVedtaksperioder(vedtaksperiodeIder) + } - override fun finnOverstyringerMedTypeForVedtaksperiode(vedtaksperiodeId: UUID): List { - return asSQL( - """ SELECT DISTINCT o.id, - CASE - WHEN oi.id IS NOT NULL THEN 'Inntekt' - WHEN oa.id IS NOT NULL THEN 'Arbeidsforhold' - WHEN ot.id IS NOT NULL THEN 'Dager' - WHEN ss.id IS NOT NULL THEN 'Sykepengegrunnlag' - WHEN oms.id IS NOT NULL THEN 'MinimumSykdomsgrad' - END as type - FROM overstyring o - LEFT JOIN overstyring_arbeidsforhold oa on o.id = oa.overstyring_ref - LEFT JOIN overstyring_inntekt oi on o.id = oi.overstyring_ref - LEFT JOIN overstyring_tidslinje ot on o.id = ot.overstyring_ref - LEFT JOIN skjonnsfastsetting_sykepengegrunnlag ss on o.id = ss.overstyring_ref - LEFT JOIN overstyring_minimum_sykdomsgrad oms on o.id = oms.overstyring_ref - WHERE o.id IN ( - SELECT overstyring_ref FROM overstyringer_for_vedtaksperioder - WHERE vedtaksperiode_id = :vedtaksperiode_id - ) - AND o.ferdigstilt = false - """, - mapOf("vedtaksperiode_id" to vedtaksperiodeId), - ).list { OverstyringType.valueOf(it.string("type")) } - } + override fun finnOverstyringerMedTypeForVedtaksperiode(vedtaksperiodeId: UUID): List = + sessionOf(dataSource).use { + TransactionalOverstyringDao(it).finnOverstyringerMedTypeForVedtaksperiode(vedtaksperiodeId) + } fun finnAktiveOverstyringer(vedtaksperiodeId: UUID): List = asSQL( diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonDao.kt index 5b252d2d2..146e06b06 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonDao.kt @@ -1,15 +1,12 @@ package no.nav.helse.modell.person import com.fasterxml.jackson.databind.JsonNode -import com.fasterxml.jackson.module.kotlin.readValue -import kotliquery.Session import kotliquery.queryOf import kotliquery.sessionOf import no.nav.helse.db.PersonRepository import no.nav.helse.db.TransactionalPersonDao import no.nav.helse.mediator.meldinger.løsninger.Inntekter import no.nav.helse.modell.kommando.MinimalPersonDto -import no.nav.helse.objectMapper import no.nav.helse.spesialist.api.person.Adressebeskyttelse import no.nav.helse.spesialist.typer.Kjønn import org.intellij.lang.annotations.Language @@ -120,13 +117,6 @@ internal class PersonDao( } } - private fun Session.finnPersonRef(fødselsnummer: String): Long? { - @Language("PostgreSQL") - val query = "SELECT id FROM person WHERE fodselsnummer=?" - - return run(queryOf(query, fødselsnummer.toLong()).map { it.longOrNull("id") }.asSingle) - } - override fun finnAdressebeskyttelse(fødselsnummer: String): Adressebeskyttelse? = sessionOf(dataSource).use { session -> session.transaction { transactionalSession -> @@ -149,59 +139,21 @@ internal class PersonDao( } override fun finnITUtbetalingsperioderSistOppdatert(fødselsnummer: String) = - sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = "SELECT infotrygdutbetalinger_oppdatert FROM person WHERE fodselsnummer=?;" - session.run( - queryOf(query, fødselsnummer.toLong()) - .map { row -> row.localDateOrNull("infotrygdutbetalinger_oppdatert") } - .asSingle, - ) - } + sessionOf(dataSource).use { TransactionalPersonDao(it).finnITUtbetalingsperioderSistOppdatert(fødselsnummer) } override fun finnInntekter( fødselsnummer: String, skjæringstidspunkt: LocalDate, - ) = sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val query = """ - SELECT * FROM inntekt - WHERE person_ref=(SELECT id FROM person WHERE fodselsnummer=:fodselsnummer) - AND skjaeringstidspunkt=:skjaeringstidspunkt; - """ - session.run( - queryOf( - query, - mapOf( - "fodselsnummer" to fødselsnummer.toLong(), - "skjaeringstidspunkt" to skjæringstidspunkt, - ), - ).map { row -> objectMapper.readValue>(row.string("inntekter")) }.asSingle, - ) + ) = sessionOf(dataSource).use { + TransactionalPersonDao(it).finnInntekter(fødselsnummer, skjæringstidspunkt) } override fun lagreInntekter( fødselsnummer: String, skjæringstidspunkt: LocalDate, inntekter: List, - ) = sessionOf(dataSource).use { session -> - session.finnPersonRef(fødselsnummer)?.also { - @Language("PostgreSQL") - val query = """ - INSERT INTO inntekt (person_ref, skjaeringstidspunkt, inntekter) - VALUES (:person_ref, :skjaeringstidspunkt, :inntekter::json) - """ - session.run( - queryOf( - query, - mapOf( - "person_ref" to it, - "skjaeringstidspunkt" to skjæringstidspunkt, - "inntekter" to objectMapper.writeValueAsString(inntekter), - ), - ).asExecute, - ) - } + ) = sessionOf(dataSource).use { + TransactionalPersonDao(it).lagreInntekter(fødselsnummer, skjæringstidspunkt, inntekter) } override fun upsertInfotrygdutbetalinger( diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonService.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonService.kt index f79a6c9e2..87fc5fb21 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonService.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/person/PersonService.kt @@ -2,8 +2,8 @@ package no.nav.helse.modell.person import kotliquery.TransactionalSession import kotliquery.sessionOf -import no.nav.helse.db.AvviksvurderingDao import no.nav.helse.db.SykefraværstilfelleDao +import no.nav.helse.db.TransactionalAvviksvurderingDao import no.nav.helse.db.TransactionalPersonDao import no.nav.helse.modell.vedtaksperiode.GenerasjonService import javax.sql.DataSource @@ -12,7 +12,6 @@ internal class PersonService( private val dataSource: DataSource, ) { private val sykefraværstilfelleDao = SykefraværstilfelleDao(dataSource) - private val avviksvurderingDao = AvviksvurderingDao(dataSource) private val generasjonService = GenerasjonService(dataSource) fun brukPersonHvisFinnes( @@ -36,8 +35,8 @@ internal class PersonService( with(sykefraværstilfelleDao) { finnSkjønnsfastsatteSykepengegrunnlag(fødselsnummer) }, )?.copy( avviksvurderinger = - with(avviksvurderingDao) { - this@hentPerson.finnAvviksvurderinger(fødselsnummer) + with(TransactionalAvviksvurderingDao(this)) { + finnAvviksvurderinger(fødselsnummer) }, )?.let { Person.gjenopprett( diff --git "a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/p\303\245vent/P\303\245VentDao.kt" "b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/p\303\245vent/P\303\245VentDao.kt" index 968f838c2..b89a58e7f 100644 --- "a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/p\303\245vent/P\303\245VentDao.kt" +++ "b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/p\303\245vent/P\303\245VentDao.kt" @@ -1,12 +1,14 @@ package no.nav.helse.modell.påvent +import kotliquery.sessionOf import no.nav.helse.HelseDao import no.nav.helse.db.PåVentRepository +import no.nav.helse.db.TransactionalPåVentDao import java.time.LocalDate import java.util.UUID import javax.sql.DataSource -class PåVentDao(dataSource: DataSource) : HelseDao(dataSource), PåVentRepository { +class PåVentDao(private val dataSource: DataSource) : HelseDao(dataSource), PåVentRepository { fun lagrePåVent( oppgaveId: Long, saksbehandlerOid: UUID, @@ -54,13 +56,11 @@ class PåVentDao(dataSource: DataSource) : HelseDao(dataSource), PåVentReposito ).update() } - override fun erPåVent(vedtaksperiodeId: UUID) = - asSQL( - """ - SELECT 1 FROM pa_vent WHERE vedtaksperiode_id = :vedtaksperiodeId - """.trimIndent(), - mapOf("vedtaksperiodeId" to vedtaksperiodeId), - ).single { it.boolean(1) } ?: false + override fun erPåVent(vedtaksperiodeId: UUID): Boolean { + sessionOf(dataSource).use { session -> + return TransactionalPåVentDao(session).erPåVent(vedtaksperiodeId) + } + } fun erPåVent(oppgaveId: Long) = asSQL( diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/risiko/RisikovurderingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/risiko/RisikovurderingDao.kt index 99ef882b0..3efc09191 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/risiko/RisikovurderingDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/risiko/RisikovurderingDao.kt @@ -1,12 +1,9 @@ package no.nav.helse.modell.risiko import com.fasterxml.jackson.databind.JsonNode -import kotliquery.queryOf import kotliquery.sessionOf import no.nav.helse.db.RisikovurderingRepository import no.nav.helse.db.TransactionalRisikovurderingDao -import no.nav.helse.objectMapper -import org.intellij.lang.annotations.Language import java.time.LocalDateTime import java.util.UUID import javax.sql.DataSource @@ -18,24 +15,14 @@ internal class RisikovurderingDao(val dataSource: DataSource) : RisikovurderingR kreverSupersaksbehandler: Boolean, data: JsonNode, opprettet: LocalDateTime, - ) { - sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val statement = """ - INSERT INTO risikovurdering_2021 (vedtaksperiode_id, kan_godkjennes_automatisk, krever_supersaksbehandler, data, opprettet) - VALUES (?, ?, ?, CAST (? AS JSON), ?); - """ - session.run( - queryOf( - statement, - vedtaksperiodeId, - kanGodkjennesAutomatisk, - kreverSupersaksbehandler, - objectMapper.writeValueAsString(data), - opprettet, - ).asUpdate, - ) - } + ) = sessionOf(dataSource).use { session -> + TransactionalRisikovurderingDao(session).lagre( + vedtaksperiodeId, + kanGodkjennesAutomatisk, + kreverSupersaksbehandler, + data, + opprettet, + ) } override fun hentRisikovurdering(vedtaksperiodeId: UUID) = @@ -45,10 +32,6 @@ internal class RisikovurderingDao(val dataSource: DataSource) : RisikovurderingR override fun kreverSupersaksbehandler(vedtaksperiodeId: UUID) = sessionOf(dataSource).use { session -> - @Language("PostgreSQL") - val statement = "SELECT krever_supersaksbehandler FROM risikovurdering_2021 WHERE vedtaksperiode_id = ? ORDER BY id DESC LIMIT 1" - session.run( - queryOf(statement, vedtaksperiodeId).map { it.boolean("krever_supersaksbehandler") }.asSingle, - ) ?: false + TransactionalRisikovurderingDao(session).kreverSupersaksbehandler(vedtaksperiodeId) } } diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/utbetaling/UtbetalingDao.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/utbetaling/UtbetalingDao.kt index dab09438d..a6788edb9 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/utbetaling/UtbetalingDao.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/utbetaling/UtbetalingDao.kt @@ -41,22 +41,8 @@ class UtbetalingDao(private val dataSource: DataSource) : HelseDao(dataSource), } } - override fun erUtbetalingForkastet(utbetalingId: UUID): Boolean { - @Language("PostgreSQL") - val query = - """ - SELECT 1 - FROM utbetaling u - JOIN utbetaling_id ui ON u.utbetaling_id_ref = ui.id - WHERE ui.utbetaling_id = :utbetaling_id - AND status = 'FORKASTET' - """.trimIndent() - return sessionOf(dataSource).use { session -> - session.run( - queryOf(query, mapOf("utbetaling_id" to utbetalingId)).map { true }.asSingle, - ) - } ?: false - } + override fun erUtbetalingForkastet(utbetalingId: UUID): Boolean = + sessionOf(dataSource).use { TransactionalUtbetalingDao(it).erUtbetalingForkastet(utbetalingId) } override fun opprettUtbetalingId( utbetalingId: UUID, diff --git a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Godkjenningsbehov.kt b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Godkjenningsbehov.kt index b2c3f46b7..4aaaafbf0 100644 --- a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Godkjenningsbehov.kt +++ b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vedtaksperiode/Godkjenningsbehov.kt @@ -1,6 +1,7 @@ package no.nav.helse.modell.vedtaksperiode import com.fasterxml.jackson.databind.JsonNode +import kotliquery.TransactionalSession import no.nav.helse.db.ArbeidsforholdRepository import no.nav.helse.db.AvviksvurderingRepository import no.nav.helse.db.CommandContextRepository @@ -95,11 +96,21 @@ internal class Godkjenningsbehov private constructor( override fun toJson() = json + override fun skalKjøresTransaksjonelt(): Boolean = true + + override fun transaksjonellBehandle( + person: Person, + kommandostarter: Kommandostarter, + transactionalSession: TransactionalSession, + ) { + kommandostarter { godkjenningsbehov(data(), person, transactionalSession) } + } + override fun behandle( person: Person, kommandostarter: Kommandostarter, ) { - kommandostarter { godkjenningsbehov(data(), person) } + throw UnsupportedOperationException() } internal fun data(): GodkjenningsbehovData = diff --git "a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vergemal/Vergem\303\245lDao.kt" "b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vergemal/Vergem\303\245lDao.kt" index 19639bba4..244a41737 100644 --- "a/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vergemal/Vergem\303\245lDao.kt" +++ "b/spesialist-selve/src/main/kotlin/no/nav/helse/modell/vergemal/Vergem\303\245lDao.kt" @@ -5,7 +5,6 @@ import kotliquery.sessionOf import no.nav.helse.db.TransactionalVergemålDao import no.nav.helse.db.VergemålRepository import org.intellij.lang.annotations.Language -import java.time.LocalDateTime import javax.sql.DataSource data class VergemålOgFremtidsfullmakt( @@ -18,40 +17,8 @@ class VergemålDao(val dataSource: DataSource) : VergemålRepository { fødselsnummer: String, vergemålOgFremtidsfullmakt: VergemålOgFremtidsfullmakt, fullmakt: Boolean, - ) { - @Language("PostgreSQL") - val statement = """ - INSERT INTO vergemal (person_ref, har_vergemal, har_fremtidsfullmakter, har_fullmakter, vergemål_oppdatert, fullmakt_oppdatert) - VALUES ( - (SELECT id FROM person WHERE fodselsnummer = :fodselsnummer), - :har_vergemal, - :har_fremtidsfullmakter, - :har_fullmakter, - :oppdatert, - :oppdatert - ) - ON CONFLICT (person_ref) - DO UPDATE SET - har_vergemal = :har_vergemal, - har_fremtidsfullmakter = :har_fremtidsfullmakter, - har_fullmakter = :har_fullmakter, - vergemål_oppdatert = :oppdatert, - fullmakt_oppdatert = :oppdatert - """ - sessionOf(dataSource).use { session -> - session.run( - queryOf( - statement, - mapOf( - "fodselsnummer" to fødselsnummer.toLong(), - "har_vergemal" to vergemålOgFremtidsfullmakt.harVergemål, - "har_fremtidsfullmakter" to vergemålOgFremtidsfullmakt.harFremtidsfullmakter, - "har_fullmakter" to fullmakt, - "oppdatert" to LocalDateTime.now(), - ), - ).asExecute, - ) - } + ) = sessionOf(dataSource).use { + TransactionalVergemålDao(it).lagre(fødselsnummer, vergemålOgFremtidsfullmakt, fullmakt) } override fun harVergemål(fødselsnummer: String): Boolean? { diff --git a/spesialist-selve/src/test/kotlin/AbstractE2ETest.kt b/spesialist-selve/src/test/kotlin/AbstractE2ETest.kt index aaf8ec8cb..841d646f7 100644 --- a/spesialist-selve/src/test/kotlin/AbstractE2ETest.kt +++ b/spesialist-selve/src/test/kotlin/AbstractE2ETest.kt @@ -672,7 +672,7 @@ internal abstract class AbstractE2ETest : AbstractDatabaseTest() { godkjenningsbehovTestdata.aktørId, godkjenningsbehovTestdata.organisasjonsnummer, ) - sisteMeldingId = sendGodkjenningsbehov(godkjenningsbehovTestdata) + sisteMeldingId = sendGodkjenningsbehov(godkjenningsbehovTestdata.copy(avviksvurderingId = avviksvurderingTestdata.avviksvurderingId)) sisteGodkjenningsbehovId = sisteMeldingId } diff --git a/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt b/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt index 574890e35..8fddd8a1e 100644 --- a/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt +++ b/spesialist-selve/src/test/kotlin/DatabaseIntegrationTest.kt @@ -1,3 +1,4 @@ + import com.expediagroup.graphql.client.types.GraphQLClientResponse import com.fasterxml.jackson.databind.SerializationFeature import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule @@ -11,7 +12,6 @@ import no.nav.helse.AbstractDatabaseTest import no.nav.helse.db.AnnulleringDao import no.nav.helse.db.BehandlingsstatistikkDao import no.nav.helse.db.EgenskapForDatabase -import no.nav.helse.db.InntektskilderDao import no.nav.helse.db.NotatDao import no.nav.helse.db.OpptegnelseDao import no.nav.helse.db.PgHistorikkinnslagRepository @@ -20,6 +20,7 @@ import no.nav.helse.db.SaksbehandlerDao import no.nav.helse.db.StansAutomatiskBehandlingDao import no.nav.helse.db.TildelingDao import no.nav.helse.db.TotrinnsvurderingDao +import no.nav.helse.db.TransactionalInntektskilderDao import no.nav.helse.januar import no.nav.helse.mediator.oppgave.OppgaveDao import no.nav.helse.modell.CommandContextDao @@ -66,6 +67,7 @@ import no.nav.helse.spleis.graphql.hentsnapshot.GraphQLGenerasjon import no.nav.helse.spleis.graphql.hentsnapshot.GraphQLPerson import no.nav.helse.spleis.graphql.hentsnapshot.GraphQLUberegnetPeriode import org.intellij.lang.annotations.Language +import org.junit.jupiter.api.AfterEach import org.junit.jupiter.api.Assertions import java.time.LocalDate import java.time.LocalDateTime @@ -164,7 +166,12 @@ abstract class DatabaseIntegrationTest : AbstractDatabaseTest() { internal val notatDao = NotatDao(dataSource) internal val annulleringDao = AnnulleringDao(dataSource) private val personService = PersonService(dataSource) - private val inntektskilderDao = InntektskilderDao(dataSource) + private val session = sessionOf(dataSource, returnGeneratedKey = true) + private val inntektskilderDao = TransactionalInntektskilderDao(session) + + @AfterEach + fun lukkSession() = + session.close() internal fun testhendelse( hendelseId: UUID = HENDELSE_ID, diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/db/InntektskilderDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/db/TxInntektskilderDaoTest.kt similarity index 96% rename from spesialist-selve/src/test/kotlin/no/nav/helse/db/InntektskilderDaoTest.kt rename to spesialist-selve/src/test/kotlin/no/nav/helse/db/TxInntektskilderDaoTest.kt index c5f0f2b0b..71e84c0a0 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/db/InntektskilderDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/db/TxInntektskilderDaoTest.kt @@ -1,6 +1,7 @@ package no.nav.helse.db import DatabaseIntegrationTest +import kotliquery.sessionOf import no.nav.helse.januar import no.nav.helse.modell.InntektskildetypeDto import no.nav.helse.modell.KomplettInntektskildeDto @@ -19,8 +20,9 @@ import java.time.LocalDate import java.time.LocalDateTime import java.util.UUID -class InntektskilderDaoTest: DatabaseIntegrationTest() { - private val dao = InntektskilderDao(dataSource) +class TxInntektskilderDaoTest: DatabaseIntegrationTest() { + private val session = sessionOf(dataSource, returnGeneratedKey = true) + private val dao = TransactionalInntektskilderDao(session) private val avviksvurderingDao = AvviksvurderingDao(dataSource) @Test diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/arbeidsgiver/ArbeidsgiverDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/arbeidsgiver/ArbeidsgiverDaoTest.kt index 0fc27ea23..075e766c6 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/arbeidsgiver/ArbeidsgiverDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/arbeidsgiver/ArbeidsgiverDaoTest.kt @@ -1,7 +1,8 @@ package no.nav.helse.modell.arbeidsgiver import DatabaseIntegrationTest -import no.nav.helse.db.InntektskilderDao +import kotliquery.sessionOf +import no.nav.helse.db.TransactionalInntektskilderDao import no.nav.helse.modell.InntektskildetypeDto.ORDINÆR import no.nav.helse.modell.KomplettInntektskildeDto import org.junit.jupiter.api.Assertions.assertEquals @@ -10,7 +11,7 @@ import org.junit.jupiter.api.Test import java.time.LocalDate internal class ArbeidsgiverDaoTest : DatabaseIntegrationTest() { - private val inntektskildeDao = InntektskilderDao(dataSource) + private val inntektskildeDao = TransactionalInntektskilderDao(sessionOf(dataSource, returnGeneratedKey = true)) @Test fun `kan hente bransjer`() { diff --git a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/overstyring/OverstyringDaoTest.kt b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/overstyring/OverstyringDaoTest.kt index 6b9a5ab9b..bc5d0a57a 100644 --- a/spesialist-selve/src/test/kotlin/no/nav/helse/modell/overstyring/OverstyringDaoTest.kt +++ b/spesialist-selve/src/test/kotlin/no/nav/helse/modell/overstyring/OverstyringDaoTest.kt @@ -1,8 +1,8 @@ package no.nav.helse.modell.overstyring import DatabaseIntegrationTest +import kotliquery.sessionOf import no.nav.helse.db.ArbeidsforholdForDatabase -import no.nav.helse.db.InntektskilderDao import no.nav.helse.db.LovhjemmelForDatabase import no.nav.helse.db.MinimumSykdomsgradForDatabase import no.nav.helse.db.OverstyrtArbeidsforholdForDatabase @@ -14,6 +14,7 @@ import no.nav.helse.db.RefusjonselementForDatabase import no.nav.helse.db.SkjønnsfastsattArbeidsgiverForDatabase import no.nav.helse.db.SkjønnsfastsattSykepengegrunnlagForDatabase import no.nav.helse.db.SkjønnsfastsettingstypeForDatabase +import no.nav.helse.db.TransactionalInntektskilderDao import no.nav.helse.januar import no.nav.helse.modell.InntektskildetypeDto.ORDINÆR import no.nav.helse.modell.KomplettInntektskildeDto @@ -35,7 +36,8 @@ import java.time.LocalDate import java.util.UUID internal class OverstyringDaoTest : DatabaseIntegrationTest() { - private val inntektskilderDao = InntektskilderDao(dataSource) + private val session = sessionOf(dataSource, returnGeneratedKey = true) + private val inntektskilderDao = TransactionalInntektskilderDao(session) private val PERSON_FORNAVN = "Per" private val PERSON_ETTERNAVN = "Son" private val PERSON_FØDSELSDATO = LocalDate.of(1998, 4, 20)