diff --git a/.nais/naiserator-dev.yaml b/.nais/naiserator-dev.yaml index 32bd88d..9e2f567 100644 --- a/.nais/naiserator-dev.yaml +++ b/.nais/naiserator-dev.yaml @@ -48,6 +48,7 @@ spec: - host: "dokarkiv.dev-fss-pub.nais.io" rules: - application: istilgangskontroll + - application: ispdfgen gcp: sqlInstances: - type: POSTGRES_15 diff --git a/.nais/naiserator-prod.yaml b/.nais/naiserator-prod.yaml index ca5b509..050f830 100644 --- a/.nais/naiserator-prod.yaml +++ b/.nais/naiserator-prod.yaml @@ -48,6 +48,7 @@ spec: - host: "dokarkiv.prod-fss-pub.nais.io" rules: - application: istilgangskontroll + - application: ispdfgen gcp: sqlInstances: - type: POSTGRES_15 diff --git a/src/main/kotlin/no/nav/syfo/App.kt b/src/main/kotlin/no/nav/syfo/App.kt index d6cee53..e9160e3 100644 --- a/src/main/kotlin/no/nav/syfo/App.kt +++ b/src/main/kotlin/no/nav/syfo/App.kt @@ -9,6 +9,8 @@ import no.nav.syfo.api.apiModule import no.nav.syfo.application.VurderingService import no.nav.syfo.infrastructure.clients.azuread.AzureAdClient import no.nav.syfo.infrastructure.clients.dokarkiv.DokarkivClient +import no.nav.syfo.infrastructure.clients.pdfgen.PdfGenClient +import no.nav.syfo.infrastructure.clients.pdfgen.VurderingPdfService import no.nav.syfo.infrastructure.clients.pdl.PdlClient import no.nav.syfo.infrastructure.clients.veiledertilgang.VeilederTilgangskontrollClient import no.nav.syfo.infrastructure.clients.wellknown.getWellKnown @@ -49,6 +51,10 @@ fun main() { azureAdClient = azureAdClient, clientEnvironment = environment.clients.istilgangskontroll, ) + val pdfGenClient = PdfGenClient( + pdfGenBaseUrl = environment.clients.ispdfgen.baseUrl, + ) + val vurderingProducer = VurderingProducer( producer = KafkaProducer(kafkaAivenProducerConfig(kafkaEnvironment = environment.kafka)) ) @@ -57,6 +63,11 @@ fun main() { pdlClient = pdlClient, ) + val vurderingPdfService = VurderingPdfService( + pdfGenClient = pdfGenClient, + pdlClient = pdlClient, + ) + val applicationEngineEnvironment = applicationEngineEnvironment { log = logger @@ -83,6 +94,7 @@ fun main() { journalforingService = journalforingService, vurderingRepository = vurderingRepository, vurderingProducer = vurderingProducer, + vurderingPdfService = vurderingPdfService, ) ) } diff --git a/src/main/kotlin/no/nav/syfo/ApplicationEnvironment.kt b/src/main/kotlin/no/nav/syfo/ApplicationEnvironment.kt index aa6ed91..656f802 100644 --- a/src/main/kotlin/no/nav/syfo/ApplicationEnvironment.kt +++ b/src/main/kotlin/no/nav/syfo/ApplicationEnvironment.kt @@ -2,6 +2,7 @@ package no.nav.syfo import no.nav.syfo.infrastructure.clients.ClientEnvironment import no.nav.syfo.infrastructure.clients.ClientsEnvironment +import no.nav.syfo.infrastructure.clients.OpenClientEnvironment import no.nav.syfo.infrastructure.clients.azuread.AzureEnvironment import no.nav.syfo.infrastructure.database.DatabaseEnvironment import no.nav.syfo.infrastructure.kafka.KafkaEnvironment @@ -39,6 +40,9 @@ data class Environment( baseUrl = getEnvVar("DOKARKIV_URL"), clientId = getEnvVar("DOKARKIV_CLIENT_ID") ), + ispdfgen = OpenClientEnvironment( + baseUrl = "http://ispdfgen" + ), ), val kafka: KafkaEnvironment = KafkaEnvironment( aivenBootstrapServers = getEnvVar("KAFKA_BROKERS"), diff --git a/src/main/kotlin/no/nav/syfo/application/IVurderingPdfService.kt b/src/main/kotlin/no/nav/syfo/application/IVurderingPdfService.kt new file mode 100644 index 0000000..56399bc --- /dev/null +++ b/src/main/kotlin/no/nav/syfo/application/IVurderingPdfService.kt @@ -0,0 +1,10 @@ +package no.nav.syfo.application + +import no.nav.syfo.domain.ManglendeMedvirkningVurdering + +interface IVurderingPdfService { + suspend fun createVurderingPdf( + vurdering: ManglendeMedvirkningVurdering, + callId: String, + ): ByteArray +} diff --git a/src/main/kotlin/no/nav/syfo/application/VurderingService.kt b/src/main/kotlin/no/nav/syfo/application/VurderingService.kt index 4b33e1d..cfbca56 100644 --- a/src/main/kotlin/no/nav/syfo/application/VurderingService.kt +++ b/src/main/kotlin/no/nav/syfo/application/VurderingService.kt @@ -13,9 +13,10 @@ class VurderingService( private val journalforingService: IJournalforingService, private val vurderingRepository: IVurderingRepository, private val vurderingProducer: IVurderingProducer, + private val vurderingPdfService: IVurderingPdfService, ) { - fun createNewVurdering( + suspend fun createNewVurdering( personident: Personident, veilederident: Veilederident, vurderingType: VurderingType, @@ -33,11 +34,14 @@ class VurderingService( type = vurderingType, ) - // TODO: Get vurdering pdf from ispdfgen + val pdf = vurderingPdfService.createVurderingPdf( + vurdering = newVurdering, + callId = callId, + ) val savedVurdering = vurderingRepository.saveManglendeMedvirkningVurdering( vurdering = newVurdering, - vurderingPdf = byteArrayOf(), + vurderingPdf = pdf, ) vurderingProducer.publishVurdering(savedVurdering) diff --git a/src/main/kotlin/no/nav/syfo/infrastructure/clients/ClientsEnvironment.kt b/src/main/kotlin/no/nav/syfo/infrastructure/clients/ClientsEnvironment.kt index de832bc..d2ba36d 100644 --- a/src/main/kotlin/no/nav/syfo/infrastructure/clients/ClientsEnvironment.kt +++ b/src/main/kotlin/no/nav/syfo/infrastructure/clients/ClientsEnvironment.kt @@ -4,6 +4,7 @@ data class ClientsEnvironment( val istilgangskontroll: ClientEnvironment, val pdl: ClientEnvironment, val dokarkiv: ClientEnvironment, + val ispdfgen: OpenClientEnvironment, ) data class ClientEnvironment( diff --git a/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/PdfGenClient.kt b/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/PdfGenClient.kt new file mode 100644 index 0000000..bd7fcd2 --- /dev/null +++ b/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/PdfGenClient.kt @@ -0,0 +1,109 @@ +package no.nav.syfo.infrastructure.clients.pdfgen + +import io.ktor.client.* +import io.ktor.client.call.* +import io.ktor.client.plugins.* +import io.ktor.client.request.* +import io.ktor.client.statement.* +import io.ktor.http.* +import io.micrometer.core.instrument.Counter +import net.logstash.logback.argument.StructuredArguments +import no.nav.syfo.infrastructure.NAV_CALL_ID_HEADER +import no.nav.syfo.infrastructure.clients.httpClientDefault +import no.nav.syfo.infrastructure.metric.METRICS_NS +import no.nav.syfo.infrastructure.metric.METRICS_REGISTRY +import org.slf4j.LoggerFactory + +class PdfGenClient( + private val httpClient: HttpClient = httpClientDefault(), + private val pdfGenBaseUrl: String +) { + + suspend fun createForhandsvarselPdf( + callId: String, + forhandsvarselPdfDTO: VurderingPdfDTO, + ): ByteArray = + getPdf( + callId = callId, + payload = forhandsvarselPdfDTO, + pdfUrl = "$pdfGenBaseUrl$API_BASE_PATH$FORHANDSVARSEL_PATH" + ) ?: throw RuntimeException("Failed to request pdf for forhandsvarsel, callId: $callId") + + suspend fun createVurderingPdf( + callId: String, + vurderingPdfDTO: VurderingPdfDTO, + ): ByteArray = + getPdf( + callId = callId, + payload = vurderingPdfDTO, + pdfUrl = "$pdfGenBaseUrl$API_BASE_PATH$VURDERING_PATH" + ) ?: throw RuntimeException("Failed to request pdf for vurdering, callId: $callId") + + suspend fun createStansPdf( + callId: String, + stansPdfDTO: VurderingPdfDTO, + ): ByteArray = + getPdf( + callId = callId, + payload = stansPdfDTO, + pdfUrl = "$pdfGenBaseUrl$API_BASE_PATH$STANS_PATH" + ) ?: throw RuntimeException("Failed to request pdf for stans, callId: $callId") + + private suspend inline fun getPdf( + callId: String, + payload: Payload, + pdfUrl: String, + ): ByteArray? = + try { + val response: HttpResponse = httpClient.post(pdfUrl) { + header(NAV_CALL_ID_HEADER, callId) + accept(ContentType.Application.Json) + contentType(ContentType.Application.Json) + setBody(payload) + } + Metrics.COUNT_CALL_PDFGEN_SUCCESS.increment() + response.body() + } catch (e: ResponseException) { + handleUnexpectedResponseException(pdfUrl, e.response, callId) + } + + private fun handleUnexpectedResponseException( + url: String, + response: HttpResponse, + callId: String, + ): ByteArray? { + log.error( + "Error while requesting PDF from ispdfgen with {}, {}, {}", + StructuredArguments.keyValue("statusCode", response.status.value.toString()), + StructuredArguments.keyValue("url", url), + StructuredArguments.keyValue("callId", callId), + ) + Metrics.COUNT_CALL_PDFGEN_FAIL.increment() + return null + } + + companion object { + private const val API_BASE_PATH = "/api/v1/genpdf/ismanglendemedvirkning" + const val FORHANDSVARSEL_PATH = "/forhandsvarsel-om-stans-av-sykepenger" + const val VURDERING_PATH = "/vurdering-av-manglende-medvirkning" + const val STANS_PATH = "/innstilling-om-stans" + + private val log = LoggerFactory.getLogger(PdfGenClient::class.java) + } +} + +private object Metrics { + private const val CALL_PDFGEN_BASE = "${METRICS_NS}_call_ispdfgen" + + private const val CALL_PDFGEN_SUCCESS = "${CALL_PDFGEN_BASE}_success_count" + private const val CALL_PDFGEN_FAIL = "${CALL_PDFGEN_BASE}_fail_count" + + val COUNT_CALL_PDFGEN_SUCCESS: Counter = Counter + .builder(CALL_PDFGEN_SUCCESS) + .description("Counts the number of successful calls to ispdfgen") + .register(METRICS_REGISTRY) + val COUNT_CALL_PDFGEN_FAIL: Counter = Counter + .builder(CALL_PDFGEN_FAIL) + .description("Counts the number of failed calls to ispdfgen") + .register(METRICS_REGISTRY) +} diff --git a/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/VurderingPdfDTO.kt b/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/VurderingPdfDTO.kt new file mode 100644 index 0000000..15ddbbc --- /dev/null +++ b/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/VurderingPdfDTO.kt @@ -0,0 +1,30 @@ +package no.nav.syfo.infrastructure.clients.pdfgen + +import no.nav.syfo.domain.DocumentComponent +import no.nav.syfo.domain.Personident +import no.nav.syfo.domain.sanitizeForPdfGen +import java.time.LocalDate +import java.time.format.DateTimeFormatter +import java.util.* + +data class VurderingPdfDTO private constructor( + val mottakerNavn: String, + val mottakerFodselsnummer: String, + val datoSendt: String, + val documentComponents: List, +) { + constructor( + mottakerNavn: String, + mottakerPersonident: Personident, + documentComponents: List, + ) : this( + mottakerNavn = mottakerNavn, + mottakerFodselsnummer = mottakerPersonident.value, + datoSendt = LocalDate.now().format(formatter), + documentComponents = documentComponents.sanitizeForPdfGen() + ) + + companion object { + private val formatter = DateTimeFormatter.ofPattern("dd. MMMM yyyy", Locale("no", "NO")) + } +} diff --git a/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/VurderingPdfService.kt b/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/VurderingPdfService.kt new file mode 100644 index 0000000..8c3f9fa --- /dev/null +++ b/src/main/kotlin/no/nav/syfo/infrastructure/clients/pdfgen/VurderingPdfService.kt @@ -0,0 +1,39 @@ +package no.nav.syfo.infrastructure.clients.pdfgen + +import no.nav.syfo.application.IVurderingPdfService +import no.nav.syfo.domain.ManglendeMedvirkningVurdering +import no.nav.syfo.domain.VurderingType +import no.nav.syfo.infrastructure.clients.pdl.PdlClient + +class VurderingPdfService( + private val pdfGenClient: PdfGenClient, + private val pdlClient: PdlClient, +) : IVurderingPdfService { + + override suspend fun createVurderingPdf( + vurdering: ManglendeMedvirkningVurdering, + callId: String, + ): ByteArray { + val personNavn = pdlClient.getPerson(vurdering.personident).fullName + val vurderingPdfDTO = VurderingPdfDTO( + documentComponents = vurdering.document, + mottakerNavn = personNavn, + mottakerPersonident = vurdering.personident, + ) + + return when (vurdering.vurderingType) { + VurderingType.FORHANDSVARSEL -> pdfGenClient.createForhandsvarselPdf( + callId = callId, + forhandsvarselPdfDTO = vurderingPdfDTO, + ) + VurderingType.OPPFYLT, VurderingType.IKKE_AKTUELL -> pdfGenClient.createVurderingPdf( + callId = callId, + vurderingPdfDTO = vurderingPdfDTO, + ) + VurderingType.STANS -> pdfGenClient.createStansPdf( + callId = callId, + stansPdfDTO = vurderingPdfDTO, + ) + } + } +} diff --git a/src/main/kotlin/no/nav/syfo/infrastructure/database/repository/VurderingRepository.kt b/src/main/kotlin/no/nav/syfo/infrastructure/database/repository/VurderingRepository.kt index 80d9f20..9b4bf77 100644 --- a/src/main/kotlin/no/nav/syfo/infrastructure/database/repository/VurderingRepository.kt +++ b/src/main/kotlin/no/nav/syfo/infrastructure/database/repository/VurderingRepository.kt @@ -305,7 +305,7 @@ private fun ResultSet.toPVarsel(): PVarsel = publishedAt = getObject("published_at", OffsetDateTime::class.java), ) -private fun ResultSet.toPVurderingPdf(): PVurderingPdf = +fun ResultSet.toPVurderingPdf(): PVurderingPdf = PVurderingPdf( id = getInt("id"), uuid = UUID.fromString(getString("uuid")), diff --git a/src/test/kotlin/no/nav/syfo/ExternalMockEnvironment.kt b/src/test/kotlin/no/nav/syfo/ExternalMockEnvironment.kt index 7ea3d2c..399600d 100644 --- a/src/test/kotlin/no/nav/syfo/ExternalMockEnvironment.kt +++ b/src/test/kotlin/no/nav/syfo/ExternalMockEnvironment.kt @@ -2,6 +2,7 @@ package no.nav.syfo import no.nav.syfo.infrastructure.clients.azuread.AzureAdClient import no.nav.syfo.infrastructure.clients.dokarkiv.DokarkivClient +import no.nav.syfo.infrastructure.clients.pdfgen.PdfGenClient import no.nav.syfo.infrastructure.clients.pdl.PdlClient import no.nav.syfo.infrastructure.clients.wellknown.WellKnown import no.nav.syfo.infrastructure.database.TestDatabase @@ -38,6 +39,10 @@ class ExternalMockEnvironment private constructor() { dokarkivEnvironment = environment.clients.dokarkiv, httpClient = mockHttpClient, ) + val pdfgenClient = PdfGenClient( + pdfGenBaseUrl = environment.clients.ispdfgen.baseUrl, + httpClient = mockHttpClient, + ) val vurderingRepository = VurderingRepository(database) companion object { diff --git a/src/test/kotlin/no/nav/syfo/TestEnvironment.kt b/src/test/kotlin/no/nav/syfo/TestEnvironment.kt index b6fbd6f..30be83e 100644 --- a/src/test/kotlin/no/nav/syfo/TestEnvironment.kt +++ b/src/test/kotlin/no/nav/syfo/TestEnvironment.kt @@ -2,6 +2,7 @@ package no.nav.syfo import no.nav.syfo.infrastructure.clients.ClientEnvironment import no.nav.syfo.infrastructure.clients.ClientsEnvironment +import no.nav.syfo.infrastructure.clients.OpenClientEnvironment import no.nav.syfo.infrastructure.clients.azuread.AzureEnvironment import no.nav.syfo.infrastructure.database.DatabaseEnvironment import no.nav.syfo.infrastructure.kafka.KafkaEnvironment @@ -40,7 +41,10 @@ fun testEnvironment() = Environment( dokarkiv = ClientEnvironment( baseUrl = "dokarkivUrl", clientId = "dokarkivClientId", - ) + ), + ispdfgen = OpenClientEnvironment( + baseUrl = "ispdfgenUrl", + ), ), electorPath = "electorPath", ) diff --git a/src/test/kotlin/no/nav/syfo/api/TestApiModule.kt b/src/test/kotlin/no/nav/syfo/api/TestApiModule.kt index a2635c7..99a4fed 100644 --- a/src/test/kotlin/no/nav/syfo/api/TestApiModule.kt +++ b/src/test/kotlin/no/nav/syfo/api/TestApiModule.kt @@ -4,6 +4,7 @@ import io.ktor.server.application.* import io.mockk.mockk import no.nav.syfo.ExternalMockEnvironment import no.nav.syfo.application.VurderingService +import no.nav.syfo.infrastructure.clients.pdfgen.VurderingPdfService import no.nav.syfo.infrastructure.clients.veiledertilgang.VeilederTilgangskontrollClient import no.nav.syfo.infrastructure.journalforing.JournalforingService import no.nav.syfo.infrastructure.kafka.VurderingProducer @@ -21,6 +22,10 @@ fun Application.testApiModule( ) val mockVurderingProducer = mockk>(relaxed = true) val vurderingProducer = VurderingProducer(producer = mockVurderingProducer) + val vurderingPdfService = VurderingPdfService( + pdfGenClient = externalMockEnvironment.pdfgenClient, + pdlClient = externalMockEnvironment.pdlClient, + ) val journalforingService = JournalforingService( dokarkivClient = externalMockEnvironment.dokarkivClient, pdlClient = externalMockEnvironment.pdlClient, @@ -30,6 +35,7 @@ fun Application.testApiModule( journalforingService = journalforingService, vurderingRepository = externalMockEnvironment.vurderingRepository, vurderingProducer = vurderingProducer, + vurderingPdfService = vurderingPdfService, ) this.apiModule( diff --git a/src/test/kotlin/no/nav/syfo/api/endpoints/ManglendeMedvirkningEndpointsSpek.kt b/src/test/kotlin/no/nav/syfo/api/endpoints/ManglendeMedvirkningEndpointsSpek.kt index 1f39607..8f44f01 100644 --- a/src/test/kotlin/no/nav/syfo/api/endpoints/ManglendeMedvirkningEndpointsSpek.kt +++ b/src/test/kotlin/no/nav/syfo/api/endpoints/ManglendeMedvirkningEndpointsSpek.kt @@ -8,6 +8,7 @@ import no.nav.syfo.ExternalMockEnvironment import no.nav.syfo.UserConstants.ARBEIDSTAKER_PERSONIDENT import no.nav.syfo.UserConstants.ARBEIDSTAKER_PERSONIDENT_VEILEDER_NO_ACCESS import no.nav.syfo.UserConstants.PDF_FORHANDSVARSEL +import no.nav.syfo.UserConstants.PDF_STANS import no.nav.syfo.UserConstants.PDF_VURDERING import no.nav.syfo.UserConstants.VEILEDER_IDENT import no.nav.syfo.api.generateJWT @@ -22,6 +23,7 @@ import no.nav.syfo.generator.generateVurdering import no.nav.syfo.infrastructure.NAV_PERSONIDENT_HEADER import no.nav.syfo.infrastructure.bearerHeader import no.nav.syfo.infrastructure.database.dropData +import no.nav.syfo.infrastructure.database.getVurderingPdf import no.nav.syfo.infrastructure.database.repository.VurderingRepository import no.nav.syfo.util.configuredJacksonMapper import org.amshove.kluent.shouldBe @@ -85,11 +87,16 @@ object ManglendeMedvirkningEndpointsSpek : Spek({ responseDTO.begrunnelse shouldBeEqualTo forhandsvarselRequestDTO.begrunnelse responseDTO.document shouldBeEqualTo forhandsvarselRequestDTO.document responseDTO.varsel?.svarfrist shouldBeEqualTo forhandsvarselRequestDTO.varselSvarfrist + + val pVurderingPdf = database.getVurderingPdf(responseDTO.uuid) + pVurderingPdf?.pdf?.size shouldBeEqualTo PDF_FORHANDSVARSEL.size + pVurderingPdf?.pdf?.get(0) shouldBeEqualTo PDF_FORHANDSVARSEL[0] + pVurderingPdf?.pdf?.get(1) shouldBeEqualTo PDF_FORHANDSVARSEL[1] } } - it("Successfully creates an STANS vurdering") { - val avslagVurdering = NewVurderingRequestDTO( + it("Successfully creates an STANS vurdering with pdf") { + val stansVurdering = NewVurderingRequestDTO( personident = ARBEIDSTAKER_PERSONIDENT, vurderingType = VurderingType.STANS, begrunnelse = "Fin begrunnelse", @@ -103,16 +110,87 @@ object ManglendeMedvirkningEndpointsSpek : Spek({ handleRequest(HttpMethod.Post, "$urlVurderinger/vurderinger") { addHeader(HttpHeaders.ContentType, ContentType.Application.Json.toString()) addHeader(HttpHeaders.Authorization, bearerHeader(validToken)) - setBody(objectMapper.writeValueAsString(avslagVurdering)) + setBody(objectMapper.writeValueAsString(stansVurdering)) + } + ) { + response.status() shouldBeEqualTo HttpStatusCode.Created + val responseDTO = objectMapper.readValue(response.content!!) + responseDTO.personident shouldBeEqualTo stansVurdering.personident + responseDTO.vurderingType shouldBeEqualTo stansVurdering.vurderingType + responseDTO.begrunnelse shouldBeEqualTo stansVurdering.begrunnelse + responseDTO.document shouldBeEqualTo stansVurdering.document + responseDTO.varsel?.svarfrist shouldBeEqualTo null + + val pVurderingPdf = database.getVurderingPdf(responseDTO.uuid) + pVurderingPdf?.pdf?.size shouldBeEqualTo PDF_STANS.size + pVurderingPdf?.pdf?.get(0) shouldBeEqualTo PDF_STANS[0] + pVurderingPdf?.pdf?.get(1) shouldBeEqualTo PDF_STANS[1] + } + } + + it("Successfully creates an OPPFYLT vurdering with pdf") { + val oppfyltVurdering = NewVurderingRequestDTO( + personident = ARBEIDSTAKER_PERSONIDENT, + vurderingType = VurderingType.OPPFYLT, + begrunnelse = "Fin begrunnelse", + document = generateDocumentComponent( + fritekst = begrunnelse, + header = "Oppfylt" + ), + varselSvarfrist = null, + ) + with( + handleRequest(HttpMethod.Post, "$urlVurderinger/vurderinger") { + addHeader(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + addHeader(HttpHeaders.Authorization, bearerHeader(validToken)) + setBody(objectMapper.writeValueAsString(oppfyltVurdering)) } ) { response.status() shouldBeEqualTo HttpStatusCode.Created val responseDTO = objectMapper.readValue(response.content!!) - responseDTO.personident shouldBeEqualTo avslagVurdering.personident - responseDTO.vurderingType shouldBeEqualTo avslagVurdering.vurderingType - responseDTO.begrunnelse shouldBeEqualTo avslagVurdering.begrunnelse - responseDTO.document shouldBeEqualTo avslagVurdering.document + responseDTO.personident shouldBeEqualTo oppfyltVurdering.personident + responseDTO.vurderingType shouldBeEqualTo oppfyltVurdering.vurderingType + responseDTO.begrunnelse shouldBeEqualTo oppfyltVurdering.begrunnelse + responseDTO.document shouldBeEqualTo oppfyltVurdering.document responseDTO.varsel?.svarfrist shouldBeEqualTo null + + val pVurderingPdf = database.getVurderingPdf(responseDTO.uuid) + pVurderingPdf?.pdf?.size shouldBeEqualTo PDF_VURDERING.size + pVurderingPdf?.pdf?.get(0) shouldBeEqualTo PDF_VURDERING[0] + pVurderingPdf?.pdf?.get(1) shouldBeEqualTo PDF_VURDERING[1] + } + } + + it("Successfully creates an IKKE AKTUELL vurdering with pdf") { + val ikkeAktuellVurdering = NewVurderingRequestDTO( + personident = ARBEIDSTAKER_PERSONIDENT, + vurderingType = VurderingType.IKKE_AKTUELL, + begrunnelse = "Fin begrunnelse", + document = generateDocumentComponent( + fritekst = begrunnelse, + header = "Oppfylt" + ), + varselSvarfrist = null, + ) + with( + handleRequest(HttpMethod.Post, "$urlVurderinger/vurderinger") { + addHeader(HttpHeaders.ContentType, ContentType.Application.Json.toString()) + addHeader(HttpHeaders.Authorization, bearerHeader(validToken)) + setBody(objectMapper.writeValueAsString(ikkeAktuellVurdering)) + } + ) { + response.status() shouldBeEqualTo HttpStatusCode.Created + val responseDTO = objectMapper.readValue(response.content!!) + responseDTO.personident shouldBeEqualTo ikkeAktuellVurdering.personident + responseDTO.vurderingType shouldBeEqualTo ikkeAktuellVurdering.vurderingType + responseDTO.begrunnelse shouldBeEqualTo ikkeAktuellVurdering.begrunnelse + responseDTO.document shouldBeEqualTo ikkeAktuellVurdering.document + responseDTO.varsel?.svarfrist shouldBeEqualTo null + + val pVurderingPdf = database.getVurderingPdf(responseDTO.uuid) + pVurderingPdf?.pdf?.size shouldBeEqualTo PDF_VURDERING.size + pVurderingPdf?.pdf?.get(0) shouldBeEqualTo PDF_VURDERING[0] + pVurderingPdf?.pdf?.get(1) shouldBeEqualTo PDF_VURDERING[1] } } diff --git a/src/test/kotlin/no/nav/syfo/application/VurderingServiceSpek.kt b/src/test/kotlin/no/nav/syfo/application/VurderingServiceSpek.kt index fa4f2a7..935ae33 100644 --- a/src/test/kotlin/no/nav/syfo/application/VurderingServiceSpek.kt +++ b/src/test/kotlin/no/nav/syfo/application/VurderingServiceSpek.kt @@ -13,8 +13,10 @@ import no.nav.syfo.domain.JournalpostId import no.nav.syfo.domain.ManglendeMedvirkningVurdering.Forhandsvarsel import no.nav.syfo.domain.VurderingType import no.nav.syfo.generator.generateVurdering +import no.nav.syfo.infrastructure.clients.pdfgen.VurderingPdfService import no.nav.syfo.infrastructure.database.dropData import no.nav.syfo.infrastructure.database.getVurdering +import no.nav.syfo.infrastructure.database.getVurderingPdf import no.nav.syfo.infrastructure.database.repository.VurderingRepository import no.nav.syfo.infrastructure.journalforing.JournalforingService import no.nav.syfo.infrastructure.kafka.VurderingProducer @@ -23,6 +25,7 @@ import no.nav.syfo.infrastructure.mock.mockedJournalpostId import org.amshove.kluent.shouldBeEqualTo import org.amshove.kluent.shouldBeGreaterThan import org.amshove.kluent.shouldBeInstanceOf +import org.amshove.kluent.shouldNotBeNull import org.apache.kafka.clients.producer.KafkaProducer import org.apache.kafka.clients.producer.ProducerRecord import org.apache.kafka.clients.producer.RecordMetadata @@ -48,11 +51,16 @@ class VurderingServiceSpek : Spek({ val vurderingProducer = VurderingProducer( producer = mockVurderingProducer, ) + val vurderingPdfService = VurderingPdfService( + externalMockEnvironment.pdfgenClient, + externalMockEnvironment.pdlClient, + ) val vurderingService = VurderingService( journalforingService = journalforingService, vurderingRepository = vurderingRepository, vurderingProducer = vurderingProducer, + vurderingPdfService = vurderingPdfService, ) afterEachTest { @@ -61,20 +69,22 @@ class VurderingServiceSpek : Spek({ val vurderingForhandsvarsel = generateVurdering(type = VurderingType.FORHANDSVARSEL) val vurderingOppfylt = generateVurdering(type = VurderingType.OPPFYLT) - val vurderingAvslag = generateVurdering(type = VurderingType.STANS) + val vurderingStans = generateVurdering(type = VurderingType.STANS) val vurderingIkkeAktuell = generateVurdering(type = VurderingType.IKKE_AKTUELL) describe("Create new vurdering") { it("Lagrer vurdering") { - val savedVurdering = vurderingService.createNewVurdering( - personident = ARBEIDSTAKER_PERSONIDENT, - veilederident = VEILEDER_IDENT, - vurderingType = VurderingType.FORHANDSVARSEL, - begrunnelse = "Begrunnelse", - document = emptyList(), - varselSvarfrist = LocalDate.now().plusDays(14), - callId = "callId", - ) + val savedVurdering = runBlocking { + vurderingService.createNewVurdering( + personident = ARBEIDSTAKER_PERSONIDENT, + veilederident = VEILEDER_IDENT, + vurderingType = VurderingType.FORHANDSVARSEL, + begrunnelse = "Begrunnelse", + document = emptyList(), + varselSvarfrist = LocalDate.now().plusDays(14), + callId = "callId", + ) + } savedVurdering.personident shouldBeEqualTo ARBEIDSTAKER_PERSONIDENT savedVurdering.veilederident shouldBeEqualTo VEILEDER_IDENT @@ -86,20 +96,25 @@ class VurderingServiceSpek : Spek({ is Forhandsvarsel -> savedVurdering.varsel.svarfrist shouldBeEqualTo LocalDate.now().plusDays(14) else -> fail("Expected savedVurdering to be an instance of Forhandsvarsel") } + + val pVurderingPdf = database.getVurderingPdf(savedVurdering.uuid) + pVurderingPdf.shouldNotBeNull() } it("Publiserer lagret vurdering på kafka") { coEvery { mockVurderingProducer.send(any()) } returns mockk>(relaxed = true) - val savedVurdering = vurderingService.createNewVurdering( - personident = ARBEIDSTAKER_PERSONIDENT, - veilederident = VEILEDER_IDENT, - vurderingType = VurderingType.FORHANDSVARSEL, - begrunnelse = "Begrunnelse", - document = emptyList(), - varselSvarfrist = LocalDate.now().plusDays(14), - callId = "callId", - ) + val savedVurdering = runBlocking { + vurderingService.createNewVurdering( + personident = ARBEIDSTAKER_PERSONIDENT, + veilederident = VEILEDER_IDENT, + vurderingType = VurderingType.FORHANDSVARSEL, + begrunnelse = "Begrunnelse", + document = emptyList(), + varselSvarfrist = LocalDate.now().plusDays(14), + callId = "callId", + ) + } val producerRecordSlot = slot>() verifyOrder { @@ -169,9 +184,9 @@ class VurderingServiceSpek : Spek({ pVurdering.journalpostId?.value shouldBeEqualTo mockedJournalpostId.toString() } - it("journalfører AVSLAG vurdering") { + it("journalfører STANS vurdering") { vurderingRepository.saveManglendeMedvirkningVurdering( - vurdering = vurderingAvslag, + vurdering = vurderingStans, vurderingPdf = PDF_STANS, ) @@ -183,7 +198,7 @@ class VurderingServiceSpek : Spek({ failed.size shouldBeEqualTo 0 success.size shouldBeEqualTo 1 - val pVurdering = database.getVurdering(vurderingAvslag.uuid) + val pVurdering = database.getVurdering(vurderingStans.uuid) pVurdering!!.type shouldBeEqualTo VurderingType.STANS pVurdering.journalpostId?.value shouldBeEqualTo mockedJournalpostId.toString() } diff --git a/src/test/kotlin/no/nav/syfo/infrastructure/database/TestDatabase.kt b/src/test/kotlin/no/nav/syfo/infrastructure/database/TestDatabase.kt index 741d712..768fbba 100644 --- a/src/test/kotlin/no/nav/syfo/infrastructure/database/TestDatabase.kt +++ b/src/test/kotlin/no/nav/syfo/infrastructure/database/TestDatabase.kt @@ -2,7 +2,9 @@ package no.nav.syfo.infrastructure.database import io.zonky.test.db.postgres.embedded.EmbeddedPostgres import no.nav.syfo.infrastructure.database.repository.PVurdering +import no.nav.syfo.infrastructure.database.repository.PVurderingPdf import no.nav.syfo.infrastructure.database.repository.toPVurdering +import no.nav.syfo.infrastructure.database.repository.toPVurderingPdf import org.flywaydb.core.Flyway import java.sql.Connection import java.util.* @@ -68,6 +70,25 @@ fun TestDatabase.getVurdering( } } +private const val queryGetVurderingPdf = + """ + SELECT pdf.* + FROM vurdering_pdf pdf INNER JOIN vurdering vu ON vu.id=pdf.vurdering_id + WHERE vu.uuid = ? + """ + +fun TestDatabase.getVurderingPdf( + vurderingUuid: UUID, +): PVurderingPdf? = + this.connection.use { connection -> + connection.prepareStatement(queryGetVurderingPdf).use { + it.setString(1, vurderingUuid.toString()) + it.executeQuery() + .toList { toPVurderingPdf() } + .firstOrNull() + } + } + class TestDatabaseNotResponding : DatabaseInterface { override val connection: Connection diff --git a/src/test/kotlin/no/nav/syfo/infrastructure/database/VurderingRepositorySpek.kt b/src/test/kotlin/no/nav/syfo/infrastructure/database/VurderingRepositorySpek.kt index 3e45bdb..80f38ad 100644 --- a/src/test/kotlin/no/nav/syfo/infrastructure/database/VurderingRepositorySpek.kt +++ b/src/test/kotlin/no/nav/syfo/infrastructure/database/VurderingRepositorySpek.kt @@ -37,7 +37,7 @@ class VurderingRepositorySpek : Spek({ journalpostId = null, ) val savedVurdering = vurderingRepository.saveManglendeMedvirkningVurdering(vurdering, pdf) - savedVurdering!!.personident shouldBeEqualTo vurdering.personident + savedVurdering.personident shouldBeEqualTo vurdering.personident savedVurdering.veilederident shouldBeEqualTo vurdering.veilederident savedVurdering.begrunnelse shouldBeEqualTo vurdering.begrunnelse savedVurdering.document shouldBeEqualTo vurdering.document diff --git a/src/test/kotlin/no/nav/syfo/infrastructure/mock/MockHttpClient.kt b/src/test/kotlin/no/nav/syfo/infrastructure/mock/MockHttpClient.kt index 89c540e..eb4d532 100644 --- a/src/test/kotlin/no/nav/syfo/infrastructure/mock/MockHttpClient.kt +++ b/src/test/kotlin/no/nav/syfo/infrastructure/mock/MockHttpClient.kt @@ -17,6 +17,9 @@ fun mockHttpClient(environment: Environment) = HttpClient(MockEngine) { ) requestUrl.startsWith("/${environment.clients.pdl.baseUrl}") -> pdlMockResponse(request) requestUrl.startsWith("/${environment.clients.dokarkiv.baseUrl}") -> dokarkivMockResponse(request) + requestUrl.startsWith("/${environment.clients.ispdfgen.baseUrl}") -> pdfGenClientMockResponse( + request + ) else -> error("Unhandled ${request.url.encodedPath}") } } diff --git a/src/test/kotlin/no/nav/syfo/infrastructure/mock/PdfGenClientMock.kt b/src/test/kotlin/no/nav/syfo/infrastructure/mock/PdfGenClientMock.kt new file mode 100644 index 0000000..f17fbcb --- /dev/null +++ b/src/test/kotlin/no/nav/syfo/infrastructure/mock/PdfGenClientMock.kt @@ -0,0 +1,23 @@ +package no.nav.syfo.infrastructure.mock + +import io.ktor.client.engine.mock.* +import io.ktor.client.request.* +import no.nav.syfo.UserConstants +import no.nav.syfo.infrastructure.clients.pdfgen.PdfGenClient + +fun MockRequestHandleScope.pdfGenClientMockResponse(request: HttpRequestData): HttpResponseData { + val requestUrl = request.url.encodedPath + + return when { + requestUrl.endsWith(PdfGenClient.Companion.FORHANDSVARSEL_PATH) -> { + respond(content = UserConstants.PDF_FORHANDSVARSEL) + } + requestUrl.endsWith(PdfGenClient.Companion.VURDERING_PATH) -> { + respond(content = UserConstants.PDF_VURDERING) + } + requestUrl.endsWith(PdfGenClient.Companion.STANS_PATH) -> { + respond(content = UserConstants.PDF_STANS) + } + else -> error("Unhandled pdf ${request.url.encodedPath}") + } +}