diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..9955b489 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,7 @@ +[*.{kt,kts}] +ktlint_code_style = intellij_idea +ktlint_standard_property-naming = disabled +max_line_length = 150 +tab_width = 4 +ktlint_standard_max-line-length = disabled +ktlint_standard_class-naming = disabled \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index b89bec2b..50a22dec 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,9 +1,23 @@ -FROM ghcr.io/navikt/baseimages/temurin:17 +FROM busybox:1.36.1-uclibc as busybox + +FROM gcr.io/distroless/java21-debian12:nonroot LABEL maintainer="Team Bidrag" \ - email="nav.ikt.prosjekt.og.forvaltning.bidrag@nav.no" + email="bidrag@nav.no" -COPY init-scripts /init-scripts -ADD ./target/bidrag-dokument-arkiv*.jar app.jar +COPY --from=busybox /bin/sh /bin/sh +COPY --from=busybox /bin/printenv /bin/printenv + +WORKDIR /app + +COPY ./target/app.jar app.jar -ENV SPRING_PROFILES_ACTIVE=nais EXPOSE 8080 +ARG JDK_JAVA_OPTIONS +ENV TZ="Europe/Oslo" +ENV SPRING_PROFILES_ACTIVE=nais +ENV JDK_JAVA_OPTIONS="-Dhttp.proxyHost=webproxy.nais \ + -Dhttps.proxyHost=webproxy.nais \ + -Dhttp.proxyPort=8088 \ + -Dhttps.proxyPort=8088 \ + -Dhttp.nonProxyHosts=localhost|127.0.0.1|10.254.0.1|*.local|*.adeo.no|*.nav.no|*.aetat.no|*.devillo.no|*.oera.no|*.nais.io|*.aivencloud.com|*.intern.dev.nav.no" +CMD ["app.jar"] \ No newline at end of file diff --git a/pom.xml b/pom.xml index e6aa1c87..d39e6362 100644 --- a/pom.xml +++ b/pom.xml @@ -1,450 +1,453 @@ - 4.0.0 - - - org.springframework.boot - spring-boot-starter-parent - 3.1.4 - - - - no.nav.bidrag.dokument - bidrag-dokument-arkiv - 1.0.233-SNAPSHOT - jar - - Backend NAIS, bidrag-dokument-arkiv, henter fra arkiv (JOARK) - https://github.com/navikt/bidrag-dokument-arkiv - - - - - 17 - 1.9.10 - - - 1.11.3 - 20231013111728_2a4d649 - 1.20230503150725_3c2c77b - 20231010134706_52d8d27 - 1.15 - 6.0.5 - 67a9be4476b63b7247cfacfaf821ab656bd2a952 - 7.3.3 - 7.3 - 9.15.2 - 2.1.0 - 4.0.2 - 4.11.0 - 3.0.11 - - - 3.3.0 - 3.8.0 - 2.22.2 - ${java.version} - UTF-8 - UTF-8 - 3.0.5 - - - - github - GitHub felles Apache Maven Packages for navikt - https://maven.pkg.github.com/navikt/maven-release/ - - - confluent - Confluent kafka - https://packages.confluent.io/maven/ - - - github-commons - https://maven.pkg.github.com/navikt/bidrag-commons - - - - - - - org.yaml - snakeyaml - 2.0 - - - org.scala-lang - scala-library - 2.13.10 - - - - - - - org.jetbrains.kotlinx - kotlinx-datetime-jvm - 0.4.0 - - - - no.nav.syfo.schemas - dok-journalfoering-hendelse-v1 - ${joark-hendelse.version} - - - io.confluent - kafka-avro-serializer - ${kafka-avro-serializer.version} - - - org.apache.commons - commons-compress - - - - - org.apache.commons - commons-compress - 1.24.0 - - - org.apache.avro - avro - ${apache-avro-version} - - - - org.springframework.boot - spring-boot-starter-cache - - - com.github.ben-manes.caffeine - caffeine - - - com.netflix.graphql.dgs - graphql-dgs-client - ${graphq-dgs-client.version} - - - io.micrometer - micrometer-registry-prometheus - - - - no.nav.bidrag - bidrag-commons - ${bidrag-commons.version} - - - no.nav.bidrag - bidrag-transport - ${bidrag-transport.version} - - - - - org.springframework.boot - spring-boot-starter-actuator - - - - org.springframework.boot - spring-boot-starter-web - - - - org.springframework.boot - spring-boot-starter-validation - - - org.springframework.boot - spring-boot-devtools - runtime - - - - org.springframework.kafka - spring-kafka - - - - - org.apache.httpcomponents.client5 - httpclient5 - - - - commons-codec - commons-codec - ${commons-codec.version} - - - - - org.jetbrains.kotlin - kotlin-stdlib-jdk8 - ${kotlin.version} - - - - io.github.microutils - kotlin-logging-jvm - ${kotlin-logging-jvm.version} - - - - - org.springdoc - springdoc-openapi-starter-webmvc-ui - ${springdoc-openapi-ui.version} - - - - - ch.qos.logback - logback-core - - - - ch.qos.logback - logback-classic - - - - net.logstash.logback - logstash-logback-encoder - ${logback-encoder.version} - - - com.fasterxml.jackson-core - jackson-databind - - - - - - org.slf4j - slf4j-api - - - - - org.aspectj - aspectjweaver - - - - - no.nav.bidrag - bidrag-commons-test - ${bidrag-commons-test.version} - test - - - - org.awaitility - awaitility-kotlin - 4.2.0 - test - - - no.nav.security - token-validation-spring-test - ${token-support.version} - test - - - com.squareup.okhttp3 - mockwebserver - ${squareup.version} - test - - - com.squareup.okhttp3 - okhttp - ${squareup.version} - test - - - org.springframework.boot - spring-boot-starter-test - test - - - - org.springframework.cloud - spring-cloud-starter-contract-stub-runner - ${springframework-cloud.version} - test - - - com.google.guava - guava - - - commons-collections - commons-collections - - - - - - org.springframework.kafka - spring-kafka-test - test - - - io.kotest - kotest-assertions-core-jvm - 5.6.1 - test - - - com.ninja-squad - springmockk - 4.0.2 - test - - - org.jetbrains.kotlin - kotlin-test - ${kotlin.version} - test - - - - - - - - + xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + 4.0.0 + + org.springframework.boot - spring-boot-maven-plugin - - - - org.jetbrains.kotlin - kotlin-maven-plugin - ${kotlin.version} - - - compile - process-sources - - compile - - - - src/main/java - src/main/kotlin - - - - - test-compile - process-test-sources - - test-compile - - - - src/test/java - src/test/kotlin - - - - - - 17 - - spring - - + spring-boot-starter-parent + 3.1.5 + + + + no.nav.bidrag.dokument + bidrag-dokument-arkiv + 1.0.233-SNAPSHOT + jar + + Backend NAIS, bidrag-dokument-arkiv, henter fra arkiv (JOARK) + https://github.com/navikt/bidrag-dokument-arkiv + + + + + 21 + 1.9.20 + + + 1.11.3 + 20231103132440_edabbf8 + 1.20230503150725_3c2c77b + 20231113102624_1040a39 + 1.16.0 + 6.0.5 + 67a9be4476b63b7247cfacfaf821ab656bd2a952 + 7.3.3 + 7.3 + 9.15.2 + 2.1.0 + 4.0.4 + 4.11.0 + 3.0.11 + + + 3.3.0 + 3.8.0 + 2.22.2 + ${java.version} + UTF-8 + UTF-8 + 3.0.5 + + + + github + GitHub felles Apache Maven Packages for navikt + https://maven.pkg.github.com/navikt/maven-release/ + + + confluent + Confluent kafka + https://packages.confluent.io/maven/ + + + github-commons + https://maven.pkg.github.com/navikt/bidrag-commons + + + + - + + org.yaml + snakeyaml + 2.2 + + + org.scala-lang + scala-library + 2.13.12 + + + + + + + org.jetbrains.kotlinx + kotlinx-datetime-jvm + 0.4.0 + + + + no.nav.syfo.schemas + dok-journalfoering-hendelse-v1 + ${joark-hendelse.version} + + + io.confluent + kafka-avro-serializer + ${kafka-avro-serializer.version} + + + org.apache.commons + commons-compress + + + + + org.apache.commons + commons-compress + 1.24.0 + + + org.apache.avro + avro + ${apache-avro-version} + + + + org.springframework.boot + spring-boot-starter-cache + + + com.github.ben-manes.caffeine + caffeine + + + com.netflix.graphql.dgs + graphql-dgs-client + ${graphq-dgs-client.version} + + + io.micrometer + micrometer-registry-prometheus + + + + no.nav.bidrag + bidrag-commons + ${bidrag-commons.version} + + + no.nav.bidrag + bidrag-transport + ${bidrag-transport.version} + + + + + org.springframework.boot + spring-boot-starter-actuator + + + + org.springframework.boot + spring-boot-starter-web + + + + org.springframework.boot + spring-boot-starter-validation + + + org.springframework.boot + spring-boot-devtools + runtime + + + + org.springframework.kafka + spring-kafka + + + + + org.apache.httpcomponents.client5 + httpclient5 + + + + commons-codec + commons-codec + ${commons-codec.version} + + + + org.jetbrains.kotlin - kotlin-maven-allopen + kotlin-stdlib-jdk8 ${kotlin.version} - - + + + + io.github.microutils + kotlin-logging-jvm + ${kotlin-logging-jvm.version} + + + + + org.springdoc + springdoc-openapi-starter-webmvc-ui + ${springdoc-openapi-ui.version} + + + + + ch.qos.logback + logback-core + + + + ch.qos.logback + logback-classic + + + + net.logstash.logback + logstash-logback-encoder + ${logback-encoder.version} + + + com.fasterxml.jackson-core + jackson-databind + + + + + + org.slf4j + slf4j-api + + + + + org.aspectj + aspectjweaver + + + + + no.nav.bidrag + bidrag-commons-test + ${bidrag-commons-test.version} + test + + + + org.awaitility + awaitility-kotlin + 4.2.0 + test + + + no.nav.security + token-validation-spring-test + ${token-support.version} + test + + + com.squareup.okhttp3 + mockwebserver + ${squareup.version} + test + + + com.squareup.okhttp3 + okhttp + ${squareup.version} + test + + + org.springframework.boot + spring-boot-starter-test + test + + + + org.springframework.cloud + spring-cloud-starter-contract-stub-runner + ${springframework-cloud.version} + test + + + com.google.guava + guava + + + commons-collections + commons-collections + + + + + + org.springframework.kafka + spring-kafka-test + test + + + io.kotest + kotest-assertions-core-jvm + 5.6.1 + test + + + com.ninja-squad + springmockk + 4.0.2 + test + + org.jetbrains.kotlin - kotlin-maven-noarg + kotlin-test ${kotlin.version} - - - - - - org.codehaus.mojo - build-helper-maven-plugin - ${build-helper-maven.version} - - - remove-old-artifacts - package - - remove-project-artifact - - - true - - - - - - org.apache.maven.plugins - maven-antrun-plugin - 3.1.0 - - - ktlint - verify - - - - - - - - - run - - - - ktlint-format - validate - - - - - - - - - - - - run - - - - - - com.pinterest - ktlint - 0.47.1 - - - - + test + + + - - + + app + + + + org.springframework.boot + spring-boot-maven-plugin + + + + org.jetbrains.kotlin + kotlin-maven-plugin + ${kotlin.version} + + + compile + process-sources + + compile + + + + src/main/java + src/main/kotlin + + + + + test-compile + process-test-sources + + test-compile + + + + src/test/java + src/test/kotlin + + + + + + 21 + + spring + + + + + org.jetbrains.kotlin + kotlin-maven-allopen + ${kotlin.version} + + + org.jetbrains.kotlin + kotlin-maven-noarg + ${kotlin.version} + + + + + + org.codehaus.mojo + build-helper-maven-plugin + ${build-helper-maven.version} + + + remove-old-artifacts + package + + remove-project-artifact + + + true + + + + + + org.apache.maven.plugins + maven-antrun-plugin + 3.1.0 + + + ktlint + verify + + + + + + + + + + run + + + + ktlint-format + validate + + + + + + + + + + + + + run + + + + + + com.pinterest.ktlint + ktlint-cli + 1.0.1 + + + + + + + diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/BidragDokumentArkivConfig.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/BidragDokumentArkivConfig.kt index d9c80964..60427e5a 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/BidragDokumentArkivConfig.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/BidragDokumentArkivConfig.kt @@ -1,373 +1,373 @@ -package no.nav.bidrag.dokument.arkiv - -import com.fasterxml.jackson.databind.ObjectMapper -import io.swagger.v3.oas.annotations.OpenAPIDefinition -import io.swagger.v3.oas.annotations.enums.SecuritySchemeType -import io.swagger.v3.oas.annotations.info.Info -import io.swagger.v3.oas.annotations.security.SecurityRequirement -import io.swagger.v3.oas.annotations.security.SecurityScheme -import no.nav.bidrag.commons.security.api.EnableSecurityConfiguration -import no.nav.bidrag.commons.security.service.SecurityTokenService -import no.nav.bidrag.commons.security.service.StsTokenService -import no.nav.bidrag.commons.web.CorrelationIdFilter -import no.nav.bidrag.commons.web.DefaultCorsFilter -import no.nav.bidrag.commons.web.HttpHeaderRestTemplate -import no.nav.bidrag.commons.web.MdcFilter -import no.nav.bidrag.commons.web.UserMdcFilter -import no.nav.bidrag.dokument.arkiv.consumer.BidragOrganisasjonConsumer -import no.nav.bidrag.dokument.arkiv.consumer.DokarkivConsumer -import no.nav.bidrag.dokument.arkiv.consumer.DokarkivKnyttTilSakConsumer -import no.nav.bidrag.dokument.arkiv.consumer.DokdistFordelingConsumer -import no.nav.bidrag.dokument.arkiv.consumer.OppgaveConsumer -import no.nav.bidrag.dokument.arkiv.consumer.PersonConsumer -import no.nav.bidrag.dokument.arkiv.consumer.SafConsumer -import no.nav.bidrag.dokument.arkiv.kafka.HendelserProducer -import no.nav.bidrag.dokument.arkiv.model.Discriminator -import no.nav.bidrag.dokument.arkiv.model.ResourceByDiscriminator -import no.nav.bidrag.dokument.arkiv.security.SaksbehandlerInfoManager -import no.nav.bidrag.dokument.arkiv.service.EndreJournalpostService -import no.nav.bidrag.dokument.arkiv.service.JournalpostService -import no.nav.bidrag.dokument.arkiv.service.OppgaveService -import org.slf4j.LoggerFactory -import org.springframework.beans.factory.annotation.Qualifier -import org.springframework.beans.factory.annotation.Value -import org.springframework.boot.web.client.RootUriTemplateHandler -import org.springframework.context.annotation.Bean -import org.springframework.context.annotation.Configuration -import org.springframework.context.annotation.Import -import org.springframework.context.annotation.Scope -import org.springframework.http.HttpHeaders -import org.springframework.http.MediaType -import org.springframework.retry.annotation.EnableRetry - -@Configuration -@EnableSecurityConfiguration -@EnableRetry -@OpenAPIDefinition( - info = Info(title = "bidrag-dokument-arkiv", version = "v1"), - security = [SecurityRequirement(name = "bearer-key")] -) -@SecurityScheme( - bearerFormat = "JWT", - name = "bearer-key", - scheme = "bearer", - type = SecuritySchemeType.HTTP -) -@Import( - CorrelationIdFilter::class, - DefaultCorsFilter::class, - UserMdcFilter::class, - StsTokenService::class, - MdcFilter::class -) -class BidragDokumentArkivConfig { - @Bean - @Scope("prototype") - fun baseSafConsumer( - @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, - environmentProperties: EnvironmentProperties - ): SafConsumer { - httpHeaderRestTemplate.uriTemplateHandler = - RootUriTemplateHandler(environmentProperties.safUrl) - httpHeaderRestTemplate.addHeaderGenerator( - HttpHeaders.CONTENT_TYPE - ) { MediaType.APPLICATION_JSON_VALUE } - return SafConsumer(httpHeaderRestTemplate) - } - - @Bean - @Scope("prototype") - fun baseOppgaveConsumer( - @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, - environmentProperties: EnvironmentProperties - ): OppgaveConsumer { - httpHeaderRestTemplate.uriTemplateHandler = - RootUriTemplateHandler(environmentProperties.oppgaveUrl) - httpHeaderRestTemplate.addHeaderGenerator( - HttpHeaders.CONTENT_TYPE - ) { MediaType.APPLICATION_JSON_VALUE } - return OppgaveConsumer(httpHeaderRestTemplate) - } - - @Bean - @Scope("prototype") - fun baseDokarkivConsumer( - @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, - environmentProperties: EnvironmentProperties, - objectMapper: ObjectMapper? - ): DokarkivConsumer { - httpHeaderRestTemplate.uriTemplateHandler = - RootUriTemplateHandler(environmentProperties.dokarkivUrl) - httpHeaderRestTemplate.addHeaderGenerator( - HttpHeaders.CONTENT_TYPE - ) { MediaType.APPLICATION_JSON_VALUE } - return DokarkivConsumer(httpHeaderRestTemplate, objectMapper) - } - - @Bean - @Scope("prototype") - fun dokdistFordelingConsumer( - @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, - environmentProperties: EnvironmentProperties, - objectMapper: ObjectMapper?, - securityTokenService: SecurityTokenService - ): DokdistFordelingConsumer { - httpHeaderRestTemplate.uriTemplateHandler = - RootUriTemplateHandler(environmentProperties.dokdistFordelingUrl) - httpHeaderRestTemplate.addHeaderGenerator( - HttpHeaders.CONTENT_TYPE - ) { MediaType.APPLICATION_JSON_VALUE } - val dokdistFordelingConsumer = - DokdistFordelingConsumer(httpHeaderRestTemplate, objectMapper) - dokdistFordelingConsumer.leggTilInterceptor( - securityTokenService.clientCredentialsTokenInterceptor(null) - ) - return dokdistFordelingConsumer - } - - @Bean - @Scope("prototype") - fun basePersonConsumer( - @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, - environmentProperties: EnvironmentProperties - ): PersonConsumer { - httpHeaderRestTemplate.uriTemplateHandler = - RootUriTemplateHandler(environmentProperties.bidragPersonUrl + "/bidrag-person") - return PersonConsumer(httpHeaderRestTemplate) - } - - @Bean - fun oppgaveService( - personConsumers: ResourceByDiscriminator, - oppgaveConsumers: ResourceByDiscriminator, - saksbehandlerInfoManager: SaksbehandlerInfoManager - ): OppgaveService { - return OppgaveService(personConsumers, oppgaveConsumers, saksbehandlerInfoManager) - } - - @Bean - fun endreJournalpostService( - journalpostServices: ResourceByDiscriminator, - dokarkivConsumers: ResourceByDiscriminator, - dokarkivKnyttTilSakConsumer: DokarkivKnyttTilSakConsumer, - hendelserProducer: HendelserProducer, - saksbehandlerInfoManager: SaksbehandlerInfoManager - ): EndreJournalpostService { - return EndreJournalpostService( - journalpostServices.get(Discriminator.REGULAR_USER), - dokarkivConsumers.get(Discriminator.REGULAR_USER), - dokarkivKnyttTilSakConsumer, - hendelserProducer, - saksbehandlerInfoManager - ) - } - - @Bean - fun journalpostServices( - safConsumers: ResourceByDiscriminator, - personConsumers: ResourceByDiscriminator - ): ResourceByDiscriminator { - val journalpostServiceRegularUser = JournalpostService( - safConsumers.get(Discriminator.REGULAR_USER), - personConsumers.get(Discriminator.SERVICE_USER) - ) - val journalpostServiceServiceUser = JournalpostService( - safConsumers.get(Discriminator.SERVICE_USER), - personConsumers.get(Discriminator.SERVICE_USER) - ) - val journalpostServices = HashMap() - journalpostServices[Discriminator.REGULAR_USER] = - journalpostServiceRegularUser - journalpostServices[Discriminator.SERVICE_USER] = journalpostServiceServiceUser - return ResourceByDiscriminator(journalpostServices) - } - - @Bean - fun safConsumers( - safConsumerRegularUser: SafConsumer, - safConsumerServiceUser: SafConsumer, - securityTokenService: SecurityTokenService - ): ResourceByDiscriminator { - safConsumerRegularUser.leggTilInterceptor(securityTokenService.authTokenInterceptor("saf")) - safConsumerServiceUser.leggTilInterceptor( - securityTokenService.clientCredentialsTokenInterceptor("saf") - ) - val safConsumers = HashMap() - safConsumers[Discriminator.REGULAR_USER] = - safConsumerRegularUser - safConsumers[Discriminator.SERVICE_USER] = safConsumerServiceUser - return ResourceByDiscriminator(safConsumers) - } - - @Bean - fun oppgaveConsumers( - oppgaveConsumerRegularUser: OppgaveConsumer, - oppgaveConsumerServiceUser: OppgaveConsumer, - securityTokenService: SecurityTokenService - ): ResourceByDiscriminator { - oppgaveConsumerRegularUser.leggTilInterceptor( - securityTokenService.authTokenInterceptor("oppgave") - ) - oppgaveConsumerServiceUser.leggTilInterceptor( - securityTokenService.clientCredentialsTokenInterceptor("oppgave") - ) - val safConsumers = HashMap() - safConsumers[Discriminator.REGULAR_USER] = oppgaveConsumerRegularUser - safConsumers[Discriminator.SERVICE_USER] = oppgaveConsumerServiceUser - return ResourceByDiscriminator(safConsumers) - } - - @Bean - fun personConsumers( - personConsumerRegularUser: PersonConsumer, - personConsumerServiceUser: PersonConsumer, - securityTokenService: SecurityTokenService - ): ResourceByDiscriminator { - personConsumerRegularUser.leggTilInterceptor( - securityTokenService.authTokenInterceptor("bidrag-person") - ) - personConsumerServiceUser.leggTilInterceptor( - securityTokenService.clientCredentialsTokenInterceptor("bidrag-person") - ) - val personConsumers = HashMap() - personConsumers[Discriminator.REGULAR_USER] = personConsumerRegularUser - personConsumers[Discriminator.SERVICE_USER] = - personConsumerServiceUser - return ResourceByDiscriminator(personConsumers) - } - - @Bean - fun dokarkivKnyttTilSakConsumer( - @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, - environmentProperties: EnvironmentProperties, - securityTokenService: SecurityTokenService - ): DokarkivKnyttTilSakConsumer { - httpHeaderRestTemplate.uriTemplateHandler = - RootUriTemplateHandler(environmentProperties.dokarkivKnyttTilSakUrl) - httpHeaderRestTemplate.addHeaderGenerator( - HttpHeaders.CONTENT_TYPE - ) { MediaType.APPLICATION_JSON_VALUE } - val dokarkivKnyttTilSakConsumer = DokarkivKnyttTilSakConsumer(httpHeaderRestTemplate) - dokarkivKnyttTilSakConsumer.leggTilInterceptor( - securityTokenService.authTokenInterceptor("dokarkiv") - ) - return dokarkivKnyttTilSakConsumer - } - - @Bean - fun dokarkivConsumers( - dokarkivConsumerRegularUser: DokarkivConsumer, - dokarkivConsumerServiceUser: DokarkivConsumer, - securityTokenService: SecurityTokenService - ): ResourceByDiscriminator { - dokarkivConsumerRegularUser.leggTilInterceptor( - securityTokenService.authTokenInterceptor("dokarkiv") - ) - dokarkivConsumerServiceUser.leggTilInterceptor( - securityTokenService.clientCredentialsTokenInterceptor("dokarkiv") - ) - val dokarkivConsumers = HashMap() - dokarkivConsumers[Discriminator.REGULAR_USER] = dokarkivConsumerRegularUser - dokarkivConsumers[Discriminator.SERVICE_USER] = dokarkivConsumerServiceUser - return ResourceByDiscriminator(dokarkivConsumers) - } - - @Bean - fun bidragOrganisasjonConsumer( - httpHeaderRestTemplate: HttpHeaderRestTemplate, - securityTokenService: SecurityTokenService, - environmentProperties: EnvironmentProperties - ): BidragOrganisasjonConsumer { - httpHeaderRestTemplate.uriTemplateHandler = RootUriTemplateHandler( - environmentProperties.bidragOrganisasjonUrl + "/bidrag-organisasjon" - ) - httpHeaderRestTemplate - .interceptors - .add(securityTokenService.clientCredentialsTokenInterceptor("bidrag-organisasjon")) - return BidragOrganisasjonConsumer(httpHeaderRestTemplate) - } - - @Bean - fun environmentProperties( - @Value("\${DOKARKIV_URL}") dokarkivUrl: String, - @Value("\${DOKARKIV_KNYTT_TIL_SAK_URL}") dokarkivKnyttTilSakUrl: String, - @Value("\${DOKDISTFORDELING_URL}") dokdistFordelingUrl: String?, - @Value("\${BIDRAG_PERSON_URL}") bidragPersonUrl: String, - @Value("\${SAF_URL}") safUrl: String, - @Value("\${OPPGAVE_URL}") oppgaveUrl: String?, - @Value("\${SRV_BD_ARKIV_AUTH}") secretForServiceUser: String, - @Value("\${ACCESS_TOKEN_URL}") securityTokenUrl: String, - @Value("\${BIDRAG_ORGANISASJON_URL}") bidragOrganisasjonUrl: String, - @Value("\${NAIS_APP_NAME}") naisAppName: String - ): EnvironmentProperties { - val environmentProperties = EnvironmentProperties( - dokdistFordelingUrl, - dokarkivUrl, - dokarkivKnyttTilSakUrl, - safUrl, - oppgaveUrl, - secretForServiceUser, - securityTokenUrl, - naisAppName, - bidragPersonUrl, - bidragOrganisasjonUrl - ) - LOGGER.info(String.format("> Environment: %s", environmentProperties)) - return environmentProperties - } - - class EnvironmentProperties( - val dokdistFordelingUrl: String?, - val dokarkivUrl: String, - val dokarkivKnyttTilSakUrl: String, - val safUrl: String, - val oppgaveUrl: String?, - val secretForServiceUser: String, - val securityTokenUrl: String, - val naisAppName: String, - val bidragPersonUrl: String, - val bidragOrganisasjonUrl: String - ) { - override fun toString(): String { - return ( - "dokarkivUrl='" + - dokarkivUrl + - '\'' + - ", safUrl='" + - safUrl + - '\'' + - ", bidragPersonUrl='" + - bidragPersonUrl + - '\'' + - ", dokarkivKnyttTilSakUrl='" + - dokarkivKnyttTilSakUrl + - '\'' + - ", securityTokenUrl='" + - securityTokenUrl + - '\'' + - ", bidragOrganisasjonUrl='" + - bidragOrganisasjonUrl + - '\'' + - ", naisAppName='" + - naisAppName + - '\'' + - ", secretForServiceUser '" + - notActualValue() + - "'." - ) - } - - private fun notActualValue(): String { - return if ("No authentication available" == secretForServiceUser) "is not initialized" else "seems to be initialized by init_srvbdarkiv.sh" - } - } - - companion object { - private val LOGGER = LoggerFactory.getLogger( - BidragDokumentArkivConfig::class.java - ) - const val PROFILE_LIVE = "live" - const val PROFILE_KAFKA_TEST = "kafka_test" - const val PROFILE_TEST = "test" - } -} +package no.nav.bidrag.dokument.arkiv + +import com.fasterxml.jackson.databind.ObjectMapper +import io.swagger.v3.oas.annotations.OpenAPIDefinition +import io.swagger.v3.oas.annotations.enums.SecuritySchemeType +import io.swagger.v3.oas.annotations.info.Info +import io.swagger.v3.oas.annotations.security.SecurityRequirement +import io.swagger.v3.oas.annotations.security.SecurityScheme +import no.nav.bidrag.commons.security.api.EnableSecurityConfiguration +import no.nav.bidrag.commons.security.service.SecurityTokenService +import no.nav.bidrag.commons.security.service.StsTokenService +import no.nav.bidrag.commons.web.CorrelationIdFilter +import no.nav.bidrag.commons.web.DefaultCorsFilter +import no.nav.bidrag.commons.web.HttpHeaderRestTemplate +import no.nav.bidrag.commons.web.MdcFilter +import no.nav.bidrag.commons.web.UserMdcFilter +import no.nav.bidrag.dokument.arkiv.consumer.BidragOrganisasjonConsumer +import no.nav.bidrag.dokument.arkiv.consumer.DokarkivConsumer +import no.nav.bidrag.dokument.arkiv.consumer.DokarkivKnyttTilSakConsumer +import no.nav.bidrag.dokument.arkiv.consumer.DokdistFordelingConsumer +import no.nav.bidrag.dokument.arkiv.consumer.OppgaveConsumer +import no.nav.bidrag.dokument.arkiv.consumer.PersonConsumer +import no.nav.bidrag.dokument.arkiv.consumer.SafConsumer +import no.nav.bidrag.dokument.arkiv.kafka.HendelserProducer +import no.nav.bidrag.dokument.arkiv.model.Discriminator +import no.nav.bidrag.dokument.arkiv.model.ResourceByDiscriminator +import no.nav.bidrag.dokument.arkiv.security.SaksbehandlerInfoManager +import no.nav.bidrag.dokument.arkiv.service.EndreJournalpostService +import no.nav.bidrag.dokument.arkiv.service.JournalpostService +import no.nav.bidrag.dokument.arkiv.service.OppgaveService +import org.slf4j.LoggerFactory +import org.springframework.beans.factory.annotation.Qualifier +import org.springframework.beans.factory.annotation.Value +import org.springframework.boot.web.client.RootUriTemplateHandler +import org.springframework.context.annotation.Bean +import org.springframework.context.annotation.Configuration +import org.springframework.context.annotation.Import +import org.springframework.context.annotation.Scope +import org.springframework.http.HttpHeaders +import org.springframework.http.MediaType +import org.springframework.retry.annotation.EnableRetry + +@Configuration +@EnableSecurityConfiguration +@EnableRetry +@OpenAPIDefinition( + info = Info(title = "bidrag-dokument-arkiv", version = "v1"), + security = [SecurityRequirement(name = "bearer-key")], +) +@SecurityScheme( + bearerFormat = "JWT", + name = "bearer-key", + scheme = "bearer", + type = SecuritySchemeType.HTTP, +) +@Import( + CorrelationIdFilter::class, + DefaultCorsFilter::class, + UserMdcFilter::class, + StsTokenService::class, + MdcFilter::class, +) +class BidragDokumentArkivConfig { + @Bean + @Scope("prototype") + fun baseSafConsumer( + @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, + environmentProperties: EnvironmentProperties, + ): SafConsumer { + httpHeaderRestTemplate.uriTemplateHandler = + RootUriTemplateHandler(environmentProperties.safUrl) + httpHeaderRestTemplate.addHeaderGenerator( + HttpHeaders.CONTENT_TYPE, + ) { MediaType.APPLICATION_JSON_VALUE } + return SafConsumer(httpHeaderRestTemplate) + } + + @Bean + @Scope("prototype") + fun baseOppgaveConsumer( + @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, + environmentProperties: EnvironmentProperties, + ): OppgaveConsumer { + httpHeaderRestTemplate.uriTemplateHandler = + RootUriTemplateHandler(environmentProperties.oppgaveUrl) + httpHeaderRestTemplate.addHeaderGenerator( + HttpHeaders.CONTENT_TYPE, + ) { MediaType.APPLICATION_JSON_VALUE } + return OppgaveConsumer(httpHeaderRestTemplate) + } + + @Bean + @Scope("prototype") + fun baseDokarkivConsumer( + @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, + environmentProperties: EnvironmentProperties, + objectMapper: ObjectMapper?, + ): DokarkivConsumer { + httpHeaderRestTemplate.uriTemplateHandler = + RootUriTemplateHandler(environmentProperties.dokarkivUrl) + httpHeaderRestTemplate.addHeaderGenerator( + HttpHeaders.CONTENT_TYPE, + ) { MediaType.APPLICATION_JSON_VALUE } + return DokarkivConsumer(httpHeaderRestTemplate, objectMapper) + } + + @Bean + @Scope("prototype") + fun dokdistFordelingConsumer( + @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, + environmentProperties: EnvironmentProperties, + objectMapper: ObjectMapper?, + securityTokenService: SecurityTokenService, + ): DokdistFordelingConsumer { + httpHeaderRestTemplate.uriTemplateHandler = + RootUriTemplateHandler(environmentProperties.dokdistFordelingUrl) + httpHeaderRestTemplate.addHeaderGenerator( + HttpHeaders.CONTENT_TYPE, + ) { MediaType.APPLICATION_JSON_VALUE } + val dokdistFordelingConsumer = + DokdistFordelingConsumer(httpHeaderRestTemplate, objectMapper) + dokdistFordelingConsumer.leggTilInterceptor( + securityTokenService.clientCredentialsTokenInterceptor(null), + ) + return dokdistFordelingConsumer + } + + @Bean + @Scope("prototype") + fun basePersonConsumer( + @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, + environmentProperties: EnvironmentProperties, + ): PersonConsumer { + httpHeaderRestTemplate.uriTemplateHandler = + RootUriTemplateHandler(environmentProperties.bidragPersonUrl + "/bidrag-person") + return PersonConsumer(httpHeaderRestTemplate) + } + + @Bean + fun oppgaveService( + personConsumers: ResourceByDiscriminator, + oppgaveConsumers: ResourceByDiscriminator, + saksbehandlerInfoManager: SaksbehandlerInfoManager, + ): OppgaveService { + return OppgaveService(personConsumers, oppgaveConsumers, saksbehandlerInfoManager) + } + + @Bean + fun endreJournalpostService( + journalpostServices: ResourceByDiscriminator, + dokarkivConsumers: ResourceByDiscriminator, + dokarkivKnyttTilSakConsumer: DokarkivKnyttTilSakConsumer, + hendelserProducer: HendelserProducer, + saksbehandlerInfoManager: SaksbehandlerInfoManager, + ): EndreJournalpostService { + return EndreJournalpostService( + journalpostServices.get(Discriminator.REGULAR_USER), + dokarkivConsumers.get(Discriminator.REGULAR_USER), + dokarkivKnyttTilSakConsumer, + hendelserProducer, + saksbehandlerInfoManager, + ) + } + + @Bean + fun journalpostServices( + safConsumers: ResourceByDiscriminator, + personConsumers: ResourceByDiscriminator, + ): ResourceByDiscriminator { + val journalpostServiceRegularUser = JournalpostService( + safConsumers.get(Discriminator.REGULAR_USER), + personConsumers.get(Discriminator.SERVICE_USER), + ) + val journalpostServiceServiceUser = JournalpostService( + safConsumers.get(Discriminator.SERVICE_USER), + personConsumers.get(Discriminator.SERVICE_USER), + ) + val journalpostServices = HashMap() + journalpostServices[Discriminator.REGULAR_USER] = + journalpostServiceRegularUser + journalpostServices[Discriminator.SERVICE_USER] = journalpostServiceServiceUser + return ResourceByDiscriminator(journalpostServices) + } + + @Bean + fun safConsumers( + safConsumerRegularUser: SafConsumer, + safConsumerServiceUser: SafConsumer, + securityTokenService: SecurityTokenService, + ): ResourceByDiscriminator { + safConsumerRegularUser.leggTilInterceptor(securityTokenService.authTokenInterceptor("saf")) + safConsumerServiceUser.leggTilInterceptor( + securityTokenService.clientCredentialsTokenInterceptor("saf"), + ) + val safConsumers = HashMap() + safConsumers[Discriminator.REGULAR_USER] = + safConsumerRegularUser + safConsumers[Discriminator.SERVICE_USER] = safConsumerServiceUser + return ResourceByDiscriminator(safConsumers) + } + + @Bean + fun oppgaveConsumers( + oppgaveConsumerRegularUser: OppgaveConsumer, + oppgaveConsumerServiceUser: OppgaveConsumer, + securityTokenService: SecurityTokenService, + ): ResourceByDiscriminator { + oppgaveConsumerRegularUser.leggTilInterceptor( + securityTokenService.authTokenInterceptor("oppgave"), + ) + oppgaveConsumerServiceUser.leggTilInterceptor( + securityTokenService.clientCredentialsTokenInterceptor("oppgave"), + ) + val safConsumers = HashMap() + safConsumers[Discriminator.REGULAR_USER] = oppgaveConsumerRegularUser + safConsumers[Discriminator.SERVICE_USER] = oppgaveConsumerServiceUser + return ResourceByDiscriminator(safConsumers) + } + + @Bean + fun personConsumers( + personConsumerRegularUser: PersonConsumer, + personConsumerServiceUser: PersonConsumer, + securityTokenService: SecurityTokenService, + ): ResourceByDiscriminator { + personConsumerRegularUser.leggTilInterceptor( + securityTokenService.authTokenInterceptor("bidrag-person"), + ) + personConsumerServiceUser.leggTilInterceptor( + securityTokenService.clientCredentialsTokenInterceptor("bidrag-person"), + ) + val personConsumers = HashMap() + personConsumers[Discriminator.REGULAR_USER] = personConsumerRegularUser + personConsumers[Discriminator.SERVICE_USER] = + personConsumerServiceUser + return ResourceByDiscriminator(personConsumers) + } + + @Bean + fun dokarkivKnyttTilSakConsumer( + @Qualifier("base") httpHeaderRestTemplate: HttpHeaderRestTemplate, + environmentProperties: EnvironmentProperties, + securityTokenService: SecurityTokenService, + ): DokarkivKnyttTilSakConsumer { + httpHeaderRestTemplate.uriTemplateHandler = + RootUriTemplateHandler(environmentProperties.dokarkivKnyttTilSakUrl) + httpHeaderRestTemplate.addHeaderGenerator( + HttpHeaders.CONTENT_TYPE, + ) { MediaType.APPLICATION_JSON_VALUE } + val dokarkivKnyttTilSakConsumer = DokarkivKnyttTilSakConsumer(httpHeaderRestTemplate) + dokarkivKnyttTilSakConsumer.leggTilInterceptor( + securityTokenService.authTokenInterceptor("dokarkiv"), + ) + return dokarkivKnyttTilSakConsumer + } + + @Bean + fun dokarkivConsumers( + dokarkivConsumerRegularUser: DokarkivConsumer, + dokarkivConsumerServiceUser: DokarkivConsumer, + securityTokenService: SecurityTokenService, + ): ResourceByDiscriminator { + dokarkivConsumerRegularUser.leggTilInterceptor( + securityTokenService.authTokenInterceptor("dokarkiv"), + ) + dokarkivConsumerServiceUser.leggTilInterceptor( + securityTokenService.clientCredentialsTokenInterceptor("dokarkiv"), + ) + val dokarkivConsumers = HashMap() + dokarkivConsumers[Discriminator.REGULAR_USER] = dokarkivConsumerRegularUser + dokarkivConsumers[Discriminator.SERVICE_USER] = dokarkivConsumerServiceUser + return ResourceByDiscriminator(dokarkivConsumers) + } + + @Bean + fun bidragOrganisasjonConsumer( + httpHeaderRestTemplate: HttpHeaderRestTemplate, + securityTokenService: SecurityTokenService, + environmentProperties: EnvironmentProperties, + ): BidragOrganisasjonConsumer { + httpHeaderRestTemplate.uriTemplateHandler = RootUriTemplateHandler( + environmentProperties.bidragOrganisasjonUrl + "/bidrag-organisasjon", + ) + httpHeaderRestTemplate + .interceptors + .add(securityTokenService.clientCredentialsTokenInterceptor("bidrag-organisasjon")) + return BidragOrganisasjonConsumer(httpHeaderRestTemplate) + } + + @Bean + fun environmentProperties( + @Value("\${DOKARKIV_URL}") dokarkivUrl: String, + @Value("\${DOKARKIV_KNYTT_TIL_SAK_URL}") dokarkivKnyttTilSakUrl: String, + @Value("\${DOKDISTFORDELING_URL}") dokdistFordelingUrl: String?, + @Value("\${BIDRAG_PERSON_URL}") bidragPersonUrl: String, + @Value("\${SAF_URL}") safUrl: String, + @Value("\${OPPGAVE_URL}") oppgaveUrl: String?, + @Value("\${SRV_BD_ARKIV_AUTH}") secretForServiceUser: String, + @Value("\${ACCESS_TOKEN_URL}") securityTokenUrl: String, + @Value("\${BIDRAG_ORGANISASJON_URL}") bidragOrganisasjonUrl: String, + @Value("\${NAIS_APP_NAME}") naisAppName: String, + ): EnvironmentProperties { + val environmentProperties = EnvironmentProperties( + dokdistFordelingUrl, + dokarkivUrl, + dokarkivKnyttTilSakUrl, + safUrl, + oppgaveUrl, + secretForServiceUser, + securityTokenUrl, + naisAppName, + bidragPersonUrl, + bidragOrganisasjonUrl, + ) + LOGGER.info(String.format("> Environment: %s", environmentProperties)) + return environmentProperties + } + + class EnvironmentProperties( + val dokdistFordelingUrl: String?, + val dokarkivUrl: String, + val dokarkivKnyttTilSakUrl: String, + val safUrl: String, + val oppgaveUrl: String?, + val secretForServiceUser: String, + val securityTokenUrl: String, + val naisAppName: String, + val bidragPersonUrl: String, + val bidragOrganisasjonUrl: String, + ) { + override fun toString(): String { + return ( + "dokarkivUrl='" + + dokarkivUrl + + '\'' + + ", safUrl='" + + safUrl + + '\'' + + ", bidragPersonUrl='" + + bidragPersonUrl + + '\'' + + ", dokarkivKnyttTilSakUrl='" + + dokarkivKnyttTilSakUrl + + '\'' + + ", securityTokenUrl='" + + securityTokenUrl + + '\'' + + ", bidragOrganisasjonUrl='" + + bidragOrganisasjonUrl + + '\'' + + ", naisAppName='" + + naisAppName + + '\'' + + ", secretForServiceUser '" + + notActualValue() + + "'." + ) + } + + private fun notActualValue(): String { + return if ("No authentication available" == secretForServiceUser) "is not initialized" else "seems to be initialized by init_srvbdarkiv.sh" + } + } + + companion object { + private val LOGGER = LoggerFactory.getLogger( + BidragDokumentArkivConfig::class.java, + ) + const val PROFILE_LIVE = "live" + const val PROFILE_KAFKA_TEST = "kafka_test" + const val PROFILE_TEST = "test" + } +} diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/RestTemplateConfiguration.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/RestTemplateConfiguration.kt index 3160af0d..27c6261d 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/RestTemplateConfiguration.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/RestTemplateConfiguration.kt @@ -20,13 +20,13 @@ class RestTemplateConfiguration { @Scope("prototype") fun restTemplate( environmentProperties: EnvironmentProperties, - observationRestTemplateCustomizer: ObservationRestTemplateCustomizer + observationRestTemplateCustomizer: ObservationRestTemplateCustomizer, ): HttpHeaderRestTemplate { val httpHeaderRestTemplate = HttpHeaderRestTemplate() httpHeaderRestTemplate.requestFactory = HttpComponentsClientHttpRequestFactory() httpHeaderRestTemplate.withDefaultHeaders() httpHeaderRestTemplate.addHeaderGenerator( - "Nav-Callid" + "Nav-Callid", ) { CorrelationId.fetchCorrelationIdForThread() } httpHeaderRestTemplate.addHeaderGenerator("Nav-Consumer-Id") { environmentProperties.naisAppName } observationRestTemplateCustomizer.customize(httpHeaderRestTemplate) diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/aop/HttpStatusRestControllerAdvice.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/aop/HttpStatusRestControllerAdvice.kt index d252dae1..8e2128bf 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/aop/HttpStatusRestControllerAdvice.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/aop/HttpStatusRestControllerAdvice.kt @@ -26,19 +26,21 @@ import org.springframework.web.method.annotation.MethodArgumentTypeMismatchExcep @RestControllerAdvice class HttpStatusRestControllerAdvice { @ResponseBody - @ExceptionHandler(value = [IllegalArgumentException::class, MethodArgumentTypeMismatchException::class, ConversionFailedException::class, HttpMessageNotReadableException::class]) + @ExceptionHandler( + value = [IllegalArgumentException::class, MethodArgumentTypeMismatchException::class, ConversionFailedException::class, HttpMessageNotReadableException::class], + ) fun handleInvalidValueExceptions(exception: Exception): ResponseEntity<*> { val valideringsFeil = hentForespørselValideringsfeil(exception) LOGGER.warn( "Forespørselen inneholder ugyldig verdi: ${valideringsFeil ?: "ukjent feil"}", - exception + exception, ) return ResponseEntity .status(HttpStatus.BAD_REQUEST) .header( HttpHeaders.WARNING, - valideringsFeil ?: exception.message + valideringsFeil ?: exception.message, ) .build() } @@ -63,7 +65,7 @@ class HttpStatusRestControllerAdvice { @ResponseBody @ExceptionHandler( - KunneIkkeJournalforeOpprettetJournalpost::class + KunneIkkeJournalforeOpprettetJournalpost::class, ) fun handleBadRequest(exception: Exception): ResponseEntity<*> { LOGGER.warn(exception.message) @@ -103,7 +105,7 @@ class HttpStatusRestControllerAdvice { @ExceptionHandler( KnyttTilSakManglerTemaException::class, OppdaterJournalpostFeiletFunksjoneltException::class, - UgyldigAvvikException::class + UgyldigAvvikException::class, ) fun ugyldigInput(exception: Exception): ResponseEntity<*> { LOGGER.warn(exception.message) diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/BidragDokumentConsumer.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/BidragDokumentConsumer.kt index e560d36e..132d2469 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/BidragDokumentConsumer.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/BidragDokumentConsumer.kt @@ -16,7 +16,7 @@ private val LOGGER = KotlinLogging.logger {} @Service class BidragDokumentConsumer( @Value("\${BIDRAG_DOKUMENT_URL}") val url: URI, - @Qualifier("azure") private val restTemplate: RestOperations + @Qualifier("azure") private val restTemplate: RestOperations, ) : AbstractRestClient(restTemplate, "bidrag_dokument") { private val dokumentUrl @@ -24,13 +24,11 @@ class BidragDokumentConsumer( UriComponentsBuilder.fromUri(url) @Retryable(backoff = Backoff(delay = 500, maxDelay = 2000, multiplier = 2.0)) - fun hentDokument( - dokumentId: String - ): ByteArray { + fun hentDokument(dokumentId: String): ByteArray { LOGGER.info { "Henter dokument bytedata for dokumentreferanse $dokumentId" } return getForNonNullEntity( dokumentUrl.pathSegment("dokumentreferanse").pathSegment(dokumentId) - .build().toUri() + .build().toUri(), ) } } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/DokdistKanalConsumer.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/DokdistKanalConsumer.kt index 1c97fc7a..9db9c2f3 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/DokdistKanalConsumer.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/DokdistKanalConsumer.kt @@ -18,7 +18,7 @@ private val LOGGER = KotlinLogging.logger {} @Service class DokdistKanalConsumer( @Value("\${DOKDISTKANAL_URL}") val url: URI, - @Qualifier("azure") private val restTemplate: RestOperations + @Qualifier("azure") private val restTemplate: RestOperations, ) : AbstractRestClient(restTemplate, "dokdistkanal") { private val dokdistkanalUrl @@ -32,15 +32,15 @@ class DokdistKanalConsumer( gjelderId: String, mottakerId: String? = null, tema: String = "BID", - forsendelseStoerrelse: Int? = null + forsendelseStoerrelse: Int? = null, ): BestemKanalResponse = postForNonNullEntity( dokdistkanalUrl.build().toUri(), BestemKanalRequest( brukerId = gjelderId, mottakerId = mottakerId ?: "11111111111", tema = tema, - forsendelseStoerrelse = forsendelseStoerrelse - ) + forsendelseStoerrelse = forsendelseStoerrelse, + ), ) } @@ -49,13 +49,13 @@ data class BestemKanalRequest( val mottakerId: String, val erArkivert: Boolean = true, val tema: String = "BID", - val forsendelseStoerrelse: Int? = null + val forsendelseStoerrelse: Int? = null, ) data class BestemKanalResponse( val regel: String, val regelBegrunnelse: String, - val distribusjonskanal: DistribusjonsKanal + val distribusjonskanal: DistribusjonsKanal, ) enum class DistribusjonsKanal { @@ -65,5 +65,5 @@ enum class DistribusjonsKanal { LOKAL_PRINT, INGEN_DISTRIBUSJON, TRYGDERETTEN, - DPVT + DPVT, } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/OppgaveConsumer.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/OppgaveConsumer.kt index 639046aa..003413fc 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/OppgaveConsumer.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/OppgaveConsumer.kt @@ -20,14 +20,16 @@ class OppgaveConsumer(restTemplate: RestTemplate?) : AbstractConsumer(restTempla pathMedParametre, HttpMethod.GET, null, - OppgaveSokResponse::class.java + OppgaveSokResponse::class.java, ).body } fun opprett(opprettOppgaveRequest: OpprettOppgaveRequest): Long? { val oppgaveResponse = restTemplate.postForEntity("/", opprettOppgaveRequest, OppgaveResponse::class.java) - LOGGER.info("Opprettet oppgave ${opprettOppgaveRequest.javaClass.simpleName} med id=${oppgaveResponse.body?.id} med type ${opprettOppgaveRequest.oppgavetype} og journalpostid ${opprettOppgaveRequest.journalpostId}") + LOGGER.info( + "Opprettet oppgave ${opprettOppgaveRequest.javaClass.simpleName} med id=${oppgaveResponse.body?.id} med type ${opprettOppgaveRequest.oppgavetype} og journalpostid ${opprettOppgaveRequest.journalpostId}", + ) return oppgaveResponse.body?.id } @@ -36,7 +38,7 @@ class OppgaveConsumer(restTemplate: RestTemplate?) : AbstractConsumer(restTempla return restTemplate.patchForObject( "/${oppgavePatch.id}", oppgavePatch, - OppgaveData::class.java + OppgaveData::class.java, ) } @@ -59,7 +61,7 @@ class OppgaveConsumer(restTemplate: RestTemplate?) : AbstractConsumer(restTempla "/$oppgaveId", HttpMethod.GET, null, - OppgaveData::class.java + OppgaveData::class.java, ).body } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/SafConsumer.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/SafConsumer.kt index 986044b9..cf35df8e 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/SafConsumer.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/consumer/SafConsumer.kt @@ -31,7 +31,7 @@ open class SafConsumer(private val restTemplate: RestTemplate) { String.format("/rest/hentdokument/%s/%s/ARKIV", journalpostId, dokumentReferanse), HttpMethod.GET, HttpEntity.EMPTY, - ByteArray::class.java + ByteArray::class.java, ) } @@ -89,9 +89,9 @@ open class SafConsumer(private val restTemplate: RestTemplate) { "Query %s med variabler (%s) feilet med feilmelding: %s", query.javaClass.simpleName, query.getVariables(), - message + message, ), - reasonToHttpStatus.status + reasonToHttpStatus.status, ) } return response diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/AvvikController.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/AvvikController.kt index a9ca6bf5..e9afb3a2 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/AvvikController.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/AvvikController.kt @@ -39,26 +39,26 @@ class AvvikController(private val avvikService: AvvikService) : BaseController() security = [SecurityRequirement(name = "bearer-key")], summary = "Henter mulige avvik for en journalpost, id på formatet '" + KildesystemIdenfikator.PREFIX_JOARK + - "'" + "'", ) @ApiResponses( value = [ ApiResponse( responseCode = "200", - description = "Tilgjengelig avvik for journalpost er hentet" + description = "Tilgjengelig avvik for journalpost er hentet", ), ApiResponse( responseCode = "404", - description = "Fant ikke journalpost som det skal hentes avvik på" - ) - ] + description = "Fant ikke journalpost som det skal hentes avvik på", + ), + ], ) fun hentAvvik( @PathVariable journalpostId: String?, @Parameter(name = "saksnummer", description = "journalposten tilhører sak") @RequestParam( - required = false + required = false, ) - saksnummer: String? + saksnummer: String?, ): ResponseEntity> { val muligSak = Optional.ofNullable(saksnummer) if (muligSak.isPresent) { @@ -71,37 +71,37 @@ class AvvikController(private val avvikService: AvvikService) : BaseController() ResponseEntity( initHttpHeadersWith( HttpHeaders.WARNING, - "Ugyldig prefix på journalpostId" + "Ugyldig prefix på journalpostId", ), - HttpStatus.BAD_REQUEST + HttpStatus.BAD_REQUEST, ) } else { ResponseEntity.ok( avvikService.hentAvvik( java.lang.Long.valueOf( - kildesystemIdenfikator.hentJournalpostId()!!.toLong() - ) - ) + kildesystemIdenfikator.hentJournalpostId()!!.toLong(), + ), + ), ) } } @PostMapping( value = [ROOT_JOURNAL + "/{journalpostId}/avvik"], - consumes = [MediaType.APPLICATION_JSON_VALUE] + consumes = [MediaType.APPLICATION_JSON_VALUE], ) @Operation( security = [SecurityRequirement(name = "bearer-key")], summary = "Behandler et avvik for en journalpost, id på formatet '" + KildesystemIdenfikator.PREFIX_JOARK_COMPLETE + - "'" + "'", ) @Transactional @ApiResponses( value = [ ApiResponse( responseCode = "200", - description = "Avvik på journalpost er behandlet" + description = "Avvik på journalpost er behandlet", ), ApiResponse( responseCode = "400", description = """En av følgende: @@ -112,34 +112,34 @@ class AvvikController(private val avvikService: AvvikService) : BaseController() - oppretting av oppgave feiler - BESTILL_SPLITTING: beskrivelse må være i avvikshendelsen - OVERFOR_TIL_ANNEN_ENHET: nyttEnhetsnummer og gammeltEnhetsnummer må være i detaljer map - """ + """, ), ApiResponse( responseCode = "503", - description = "Oppretting av oppgave for avviket feilet" - ) - ] + description = "Oppretting av oppgave for avviket feilet", + ), + ], ) fun behandleAvvik( @PathVariable journalpostId: String?, @RequestBody avvikshendelse: Avvikshendelse, - @RequestHeader(EnhetFilter.X_ENHET_HEADER) enhet: String? + @RequestHeader(EnhetFilter.X_ENHET_HEADER) enhet: String?, ): ResponseEntity { LOGGER.info( "Behandle avvik {} for journalpost {}", avvikshendelse.avvikType, - journalpostId + journalpostId, ) SECURE_LOGGER.info( "Behandle avvik {} for journalpost {}: {}", avvikshendelse.avvikType, journalpostId, - avvikshendelse + avvikshendelse, ) val kildesystemIdenfikator = KildesystemIdenfikator(journalpostId!!) if (kildesystemIdenfikator.erUkjentPrefixEllerHarIkkeTallEtterPrefix()) { return ResponseEntity( initHttpHeadersWith(HttpHeaders.WARNING, "Ugyldig prefix på journalpostId"), - HttpStatus.BAD_REQUEST + HttpStatus.BAD_REQUEST, ) } val muligAvvikstype = avvikshendelse.hent() @@ -148,20 +148,20 @@ class AvvikController(private val avvikService: AvvikService) : BaseController() "BAD REQUEST: avvikshendelse: %s, mulig avvik: %s, enhet: %s", avvikshendelse, muligAvvikstype, - enhet + enhet, ) LOGGER.warn(message) return ResponseEntity( initHttpHeadersWith(HttpHeaders.WARNING, message), - HttpStatus.BAD_REQUEST + HttpStatus.BAD_REQUEST, ) } val behandleAvvikResponse = avvikService.behandleAvvik( AvvikshendelseIntern( avvikshendelse, enhet, - kildesystemIdenfikator.hentJournalpostId()!!.toLong() - ) + kildesystemIdenfikator.hentJournalpostId()!!.toLong(), + ), ) return ResponseEntity.ok(behandleAvvikResponse) } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerController.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerController.kt index b65822e5..18b4de0e 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerController.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerController.kt @@ -37,24 +37,24 @@ class DistribuerController(private val distribuerJournalpostService: DistribuerJ value = [ ApiResponse( responseCode = "200", - description = "Distribusjon av journalpost er bestilt" + description = "Distribusjon av journalpost er bestilt", ), ApiResponse( responseCode = "400", - description = "Journalpost mangler mottakerid eller adresse er ikke oppgitt i kallet" - ) - ] + description = "Journalpost mangler mottakerid eller adresse er ikke oppgitt i kallet", + ), + ], ) @ResponseBody fun distribuerJournalpost( @RequestBody(required = false) distribuerJournalpostRequest: DistribuerJournalpostRequest?, @PathVariable joarkJournalpostId: String, - @RequestParam(required = false, name = "batchId") batchIdHeader: String? + @RequestParam(required = false, name = "batchId") batchIdHeader: String?, ): ResponseEntity { val batchId = if (Strings.isEmpty(batchIdHeader)) null else batchIdHeader LOGGER.info( "Distribuerer journalpost {}{}", joarkJournalpostId, - if (Strings.isNotEmpty(batchId)) String.format(" og batchId %s", batchId) else "" + if (Strings.isNotEmpty(batchId)) String.format(" og batchId %s", batchId) else "", ) val kildesystemIdenfikator = KildesystemIdenfikator(joarkJournalpostId!!) if (kildesystemIdenfikator.erUkjentPrefixEllerHarIkkeTallEtterPrefix()) { @@ -70,8 +70,8 @@ class DistribuerController(private val distribuerJournalpostService: DistribuerJ distribuerJournalpostService.distribuerJournalpost( journalpostId!!, batchId, - DistribuerJournalpostRequestInternal(distribuerJournalpostRequest) - ) + DistribuerJournalpostRequestInternal(distribuerJournalpostRequest), + ), ) } @@ -81,12 +81,12 @@ class DistribuerController(private val distribuerJournalpostService: DistribuerJ value = [ ApiResponse( responseCode = "200", - description = "Distribusjon av journalpost kan bestilles" + description = "Distribusjon av journalpost kan bestilles", ), ApiResponse( responseCode = "406", - description = "Distribusjon av journalpost kan ikke bestilles" - ) - ] + description = "Distribusjon av journalpost kan ikke bestilles", + ), + ], ) @ResponseBody fun kanDistribuerJournalpost(@PathVariable journalpostId: String): ResponseEntity { @@ -116,14 +116,14 @@ class DistribuerController(private val distribuerJournalpostService: DistribuerJ value = [ ApiResponse( responseCode = "200", - description = "Hentet informasjon om distribusjon av journalpost" + description = "Hentet informasjon om distribusjon av journalpost", ), ApiResponse( responseCode = "202", - description = "Journalpost er ikke distribuert eller er av type NOTAT eller INNGÅENDE" + description = "Journalpost er ikke distribuert eller er av type NOTAT eller INNGÅENDE", ), - ApiResponse(responseCode = "404", description = "Fant ikke journalpost") - ] + ApiResponse(responseCode = "404", description = "Fant ikke journalpost"), + ], ) @ResponseBody fun hentDistribusjonsInfo(@PathVariable journalpostId: String): ResponseEntity { @@ -151,9 +151,9 @@ class DistribuerController(private val distribuerJournalpostService: DistribuerJ value = [ ApiResponse( responseCode = "200", - description = "Hentet informasjon om hvilken kanal mottaker vil motta forsendelse på" - ) - ] + description = "Hentet informasjon om hvilken kanal mottaker vil motta forsendelse på", + ), + ], ) @ResponseBody fun hentDistribusjonKanal(@RequestBody request: BestemDistribusjonKanalRequest): BestemKanalResponse { diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DokumentController.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DokumentController.kt index d4531720..ed506a6b 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DokumentController.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/DokumentController.kt @@ -27,52 +27,49 @@ class DokumentController(private val dokumentService: DokumentService) { @GetMapping(value = ["/dokument/{journalpostId}/{dokumentreferanse}"]) @Operation( security = [SecurityRequirement(name = "bearer-key")], - summary = "Henter dokument fra Joark for journalpostid og dokumentreferanse. " + summary = "Henter dokument fra Joark for journalpostid og dokumentreferanse. ", ) @ApiResponses( value = [ ApiResponse( responseCode = "200", - description = "OK - dokument returneres i form av base64 encoded string." + description = "OK - dokument returneres i form av base64 encoded string.", ), ApiResponse( responseCode = "404", - description = "Fant ikke journalpost med oppgitt dokumentreferanse" - ) - ] + description = "Fant ikke journalpost med oppgitt dokumentreferanse", + ), + ], ) - fun hentDokument( - @PathVariable journalpostId: String, - @PathVariable dokumentreferanse: String - ): ResponseEntity { + fun hentDokument(@PathVariable journalpostId: String, @PathVariable dokumentreferanse: String): ResponseEntity { val kildesystemIdenfikator = KildesystemIdenfikator(journalpostId) return if (kildesystemIdenfikator.erUkjentPrefixEllerHarIkkeTallEtterPrefix()) { ResponseEntity( WebUtil.initHttpHeadersWith( HttpHeaders.WARNING, - "Ugyldig prefix på journalpostId" + "Ugyldig prefix på journalpostId", ), - HttpStatus.BAD_REQUEST + HttpStatus.BAD_REQUEST, ) } else { dokumentService.hentDokument( kildesystemIdenfikator.hentJournalpostIdLong()!!, - dokumentreferanse + dokumentreferanse, ) } } @RequestMapping( value = ["/dokument/{journalpostId}/{dokumentreferanse}", "/dokument/{journalpostId}", "/dokumentreferanse/{dokumentreferanse}"], - method = [RequestMethod.OPTIONS] + method = [RequestMethod.OPTIONS], ) @Operation( security = [SecurityRequirement(name = "bearer-key")], - summary = "Henter dokument for journalpostid og dokumentreferanse. " + summary = "Henter dokument for journalpostid og dokumentreferanse. ", ) fun hentDokumentMetadata( @PathVariable(required = false) journalpostId: String?, - @PathVariable(required = false) dokumentreferanse: String? + @PathVariable(required = false) dokumentreferanse: String?, ): ResponseEntity> { LOGGER.info("Henter dokument for journalpost $journalpostId og dokumentId $dokumentreferanse") if (journalpostId.isNullOrEmpty() && dokumentreferanse.isNullOrEmpty()) { @@ -80,7 +77,7 @@ class DokumentController(private val dokumentService: DokumentService) { .badRequest() .header( HttpHeaders.WARNING, - "Kan ikke hente dokument uten journalpostId eller dokumentereferanse" + "Kan ikke hente dokument uten journalpostId eller dokumentereferanse", ) .build() } @@ -97,8 +94,8 @@ class DokumentController(private val dokumentService: DokumentService) { ResponseEntity.ok( dokumentService.hentDokumentMetadata( kildesystemIdenfikator.hentJournalpostIdLong(), - dokumentreferanse - ) + dokumentreferanse, + ), ) } } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostController.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostController.kt index 9e53055d..78a4691f 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostController.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostController.kt @@ -33,7 +33,7 @@ import org.springframework.web.bind.annotation.RestController @Protected class JournalpostController( journalpostService: ResourceByDiscriminator, - private val endreJournalpostService: EndreJournalpostService + private val endreJournalpostService: EndreJournalpostService, ) : BaseController() { private val journalpostService: JournalpostService @@ -44,27 +44,27 @@ class JournalpostController( @GetMapping("$ROOT_JOURNAL/{joarkJournalpostId}") @Operation( description = "Hent en journalpost for en id på formatet '" + KildesystemIdenfikator.PREFIX_JOARK_COMPLETE + "'", - security = [SecurityRequirement(name = "bearer-key")] + security = [SecurityRequirement(name = "bearer-key")], ) @ApiResponses( value = [ ApiResponse(responseCode = "200", description = "Journalpost er hentet"), ApiResponse( responseCode = "400", - description = "Journalpost som skal hentes er ikke koblet mot gitt saksnummer, eller det er feil prefix/id på journalposten" + description = "Journalpost som skal hentes er ikke koblet mot gitt saksnummer, eller det er feil prefix/id på journalposten", ), ApiResponse( responseCode = "404", - description = "Fant ikke journalpost som skal hentes" - ) - ] + description = "Fant ikke journalpost som skal hentes", + ), + ], ) fun hentJournalpost( @PathVariable joarkJournalpostId: String, - @RequestParam(required = false) saksnummer: String? + @RequestParam(required = false) saksnummer: String?, ): ResponseEntity { LOGGER.info("Henter journalpost {} med saksnummer {}", joarkJournalpostId, saksnummer) val kildesystemIdenfikator = KildesystemIdenfikator(joarkJournalpostId) if (kildesystemIdenfikator.erUkjentPrefixEllerHarIkkeTallEtterPrefix() || erIkkePrefixetMedJoark( - joarkJournalpostId + joarkJournalpostId, ) ) { return ResponseEntity @@ -77,14 +77,14 @@ class JournalpostController( .badRequest() .header( HttpHeaders.WARNING, - "Kunne ikke hente id fra prefikset journalpostId: $joarkJournalpostId" + "Kunne ikke hente id fra prefikset journalpostId: $joarkJournalpostId", ) .build() return journalpostService.hentJournalpostMedFnrOgTilknyttedeSaker( java.lang.Long.valueOf( - journalpostId.toLong() + journalpostId.toLong(), ), - saksnummer + saksnummer, ) .map { journalpost: Journalpost -> ResponseEntity.ok(journalpost.tilJournalpostResponse()) } .orElse( @@ -94,10 +94,10 @@ class JournalpostController( String.format( "Fant ingen journalpost med id %s og saksnummer %s", journalpostId, - saksnummer - ) + saksnummer, + ), ) - .build() + .build(), ) } @@ -106,56 +106,57 @@ class JournalpostController( } @GetMapping("/sak/{saksnummer}/journal") - @Operation(description = "Finn journalposter for et saksnummer og fagområde. Parameter fagomrade=BID er bidragjournal og fagomrade=FAR er farskapsjournal") + @Operation( + description = "Finn journalposter for et saksnummer og fagområde. Parameter fagomrade=BID er bidragjournal og fagomrade=FAR er farskapsjournal", + ) @ApiResponses( value = [ ApiResponse( responseCode = "200", - description = "Liste over journalposter for saksnummer og fagområde" + description = "Liste over journalposter for saksnummer og fagområde", ), ApiResponse( responseCode = "404", - description = "Fant ikke journalposter for oppgitt sak og fagområde" - ) - ] + description = "Fant ikke journalposter for oppgitt sak og fagområde", + ), + ], ) - fun hentJournal( - @PathVariable saksnummer: String, - @RequestParam fagomrade: List = emptyList() - ): ResponseEntity> { + fun hentJournal(@PathVariable saksnummer: String, @RequestParam fagomrade: List = emptyList()): ResponseEntity> { LOGGER.info("Henter journal for saksnummer {} og tema {}", saksnummer, fagomrade) return ResponseEntity.ok(journalpostService.finnJournalposter(saksnummer, fagomrade)) } @PatchMapping("$ROOT_JOURNAL/{joarkJournalpostId}") - @Operation(description = "endre eksisterende journalpost med journalpostId på formatet '" + KildesystemIdenfikator.PREFIX_JOARK_COMPLETE + "'") + @Operation( + description = "endre eksisterende journalpost med journalpostId på formatet '" + KildesystemIdenfikator.PREFIX_JOARK_COMPLETE + "'", + ) @ApiResponses( value = [ ApiResponse(responseCode = "203", description = "Journalpost er endret"), ApiResponse( responseCode = "400", - description = "Prefiks på journalpostId er ugyldig, JournalpostEndreJournalpostCommandDto.gjelder er ikke satt eller det ikke finnes en journalpost på gitt id" + description = "Prefiks på journalpostId er ugyldig, JournalpostEndreJournalpostCommandDto.gjelder er ikke satt eller det ikke finnes en journalpost på gitt id", ), ApiResponse( responseCode = "404", - description = "Fant ikke journalpost som skal endres, ingen 'payload' eller feil prefix/id på journalposten" - ) - ] + description = "Fant ikke journalpost som skal endres, ingen 'payload' eller feil prefix/id på journalposten", + ), + ], ) fun patch( @RequestBody endreJournalpostCommand: EndreJournalpostCommand, @PathVariable joarkJournalpostId: String, - @RequestHeader(EnhetFilter.X_ENHET_HEADER) enhet: String? + @RequestHeader(EnhetFilter.X_ENHET_HEADER) enhet: String?, ): ResponseEntity { LOGGER.info("Mottatt oppdater journalpost {} kall", joarkJournalpostId) SECURE_LOGGER.info( "Oppdater journalpost {} med body: {}", joarkJournalpostId, - endreJournalpostCommand + endreJournalpostCommand, ) val kildesystemIdenfikator = KildesystemIdenfikator(joarkJournalpostId) if (kildesystemIdenfikator.erUkjentPrefixEllerHarIkkeTallEtterPrefix()) { val msgBadRequest = String.format( "Id har ikke riktig prefix: %s eller det mangler gjelder person %s", joarkJournalpostId, - endreJournalpostCommand + endreJournalpostCommand, ) LOGGER.warn(msgBadRequest) return ResponseEntity @@ -165,9 +166,9 @@ class JournalpostController( } endreJournalpostService.endre( java.lang.Long.valueOf( - kildesystemIdenfikator.hentJournalpostId()!!.toLong() + kildesystemIdenfikator.hentJournalpostId()!!.toLong(), ), - EndreJournalpostCommandIntern(endreJournalpostCommand, enhet!!) + EndreJournalpostCommandIntern(endreJournalpostCommand, enhet!!), ) return ResponseEntity(HttpStatus.OK) } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostController.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostController.kt index f64e680c..3eaf6574 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostController.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostController.kt @@ -23,23 +23,23 @@ class OpprettJournalpostController(private val opprettJournalpostService: Oppret @PostMapping("/journalpost") @Operation( security = [SecurityRequirement(name = "bearer-key")], - description = "Opprett journalpost i Joark" + description = "Opprett journalpost i Joark", ) @ApiResponses( value = [ ApiResponse( responseCode = "400", - description = "Opprett journalpost kalt med ugyldig data" - ) - ] + description = "Opprett journalpost kalt med ugyldig data", + ), + ], ) fun opprettJournalpost(@RequestBody opprettJournalpostRequest: OpprettJournalpostRequest): ResponseEntity { SECURE_LOGGER.info("Oppretter journalpost {}", opprettJournalpostRequest) validerKanOppretteJournalpost(opprettJournalpostRequest) return ResponseEntity.ok( opprettJournalpostService.opprettJournalpost( - opprettJournalpostRequest - ) + opprettJournalpostRequest, + ), ) } } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BehandleOppgaveHendelseService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BehandleOppgaveHendelseService.kt index 3da16cc9..a0564426 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BehandleOppgaveHendelseService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BehandleOppgaveHendelseService.kt @@ -26,7 +26,7 @@ class BehandleOppgaveHendelseService( dokarkivConsumers: ResourceByDiscriminator, oppgaveConsumers: ResourceByDiscriminator, journalpostServices: ResourceByDiscriminator, - private val meterRegistry: MeterRegistry + private val meterRegistry: MeterRegistry, ) { private val dokarkivConsumer: DokarkivConsumer private val oppgaveConsumer: OppgaveConsumer @@ -43,7 +43,7 @@ class BehandleOppgaveHendelseService( @Retryable( value = [JournalpostHarIkkeKommetIRetur::class], maxAttempts = 5, - backoff = Backoff(delay = 1000, maxDelay = 12000, multiplier = 2.0) + backoff = Backoff(delay = 1000, maxDelay = 12000, multiplier = 2.0), ) fun behandleReturOppgaveOpprettetHendelse(oppgaveHendelse: OppgaveKafkaHendelse) { val oppgave = validerOgHentOppgave(oppgaveHendelse) ?: return @@ -56,8 +56,8 @@ class BehandleOppgaveHendelseService( dokarkivConsumer.endre( OpprettNyReturLoggRequest( journalpost, - opprettKommentarSomLeggesTilReturlogg(journalpost) - ) + opprettKommentarSomLeggesTilReturlogg(journalpost), + ), ) LOGGER.info { "Lagt til ny returlogg med returdato ${LocalDate.now()} på journalpost ${journalpost.journalpostId} med dokumentdato ${journalpost.hentDatoDokument()}." @@ -67,7 +67,7 @@ class BehandleOppgaveHendelseService( "Journalpost ${oppgave.journalpostId} har ikke kommet i retur. Det kan hende dette skyldes race-condition hvor retur oppgave er opprettet før journalpost er oppdatert. Forsøker på nytt." } throw JournalpostHarIkkeKommetIRetur( - "Journalpost ${oppgave.journalpostId} har ikke kommet i retur" + "Journalpost ${oppgave.journalpostId} har ikke kommet i retur", ) } else { LOGGER.warn { @@ -92,14 +92,14 @@ class BehandleOppgaveHendelseService( val oppgave = oppgaveConsumer.hentOppgave(oppgaveHendelse.oppgaveId) if (oppgave == null) { LOGGER.warn( - "Fant ingen oppgave med id ${oppgaveHendelse.oppgaveId}" + "Fant ingen oppgave med id ${oppgaveHendelse.oppgaveId}", ) return null } if (oppgave.journalpostId.isNullOrEmpty()) { LOGGER.warn( - "Returoppgave ${oppgave.id} har ingen journalpostid. Avslutter behandling" + "Returoppgave ${oppgave.id} har ingen journalpostid. Avslutter behandling", ) return null } @@ -107,10 +107,7 @@ class BehandleOppgaveHendelseService( return oppgave } - private fun oppdaterOppgaveSaksreferanse( - journalpost: Journalpost, - oppgave: OppgaveData - ) { + private fun oppdaterOppgaveSaksreferanse(journalpost: Journalpost, oppgave: OppgaveData) { try { val kommentar = opprettKommentarSomLeggesTilOppgave(journalpost) if (oppgave.saksreferanse != journalpost.hentSaksnummer()) { @@ -118,8 +115,8 @@ class BehandleOppgaveHendelseService( OppdaterSakRequest( oppgave, journalpost.hentSaksnummer(), - kommentar - ) + kommentar, + ), ) LOGGER.info { "Oppdatert returoppgave ${oppgave.id} saksreferanse til ${journalpost.hentSaksnummer()} og lagt til kommentar $kommentar. JournalpostId=${journalpost.journalpostId}" @@ -136,12 +133,12 @@ class BehandleOppgaveHendelseService( } } - private fun Journalpost.harReturKommetFraNavNo() = - distribuertTilAdresse() == null && tilleggsopplysninger.isOriginalDistribuertDigitalt() + private fun Journalpost.harReturKommetFraNavNo() = distribuertTilAdresse() == null && tilleggsopplysninger.isOriginalDistribuertDigitalt() private fun opprettKommentarSomLeggesTilOppgave(journalpost: Journalpost): String? { SECURE_LOGGER.info( - "Journalpost kommet retur med følgende detaljer origDistDigitalt=${journalpost.tilleggsopplysninger.isOriginalDistribuertDigitalt()} jpId=${journalpost.journalpostId} status=${journalpost.journalstatus} adresse=${journalpost.distribuertTilAdresse()}" + "Journalpost kommet retur med følgende detaljer origDistDigitalt=${journalpost.tilleggsopplysninger.isOriginalDistribuertDigitalt()} " + + "jpId=${journalpost.journalpostId} status=${journalpost.journalstatus} adresse=${journalpost.distribuertTilAdresse()}", ) return if (journalpost.harReturKommetFraNavNo()) "Mottaker har ikke åpnet forsendelsen via www.nav.no innen 40 timer. Ingen postadresse er registrert. Vurder om mottaker har adresse forsendelsen kan sendes til." else null } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BidragDokumentArkivKafkaConfig.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BidragDokumentArkivKafkaConfig.kt index 01b42341..f571b9bb 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BidragDokumentArkivKafkaConfig.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/BidragDokumentArkivKafkaConfig.kt @@ -41,14 +41,14 @@ class BidragDokumentArkivKafkaConfig { objectMapper: ObjectMapper, saksbehandlerInfoManager: SaksbehandlerInfoManager, @Value("\${TOPIC_JOURNALPOST}") topic: String, - journalpostServices: ResourceByDiscriminator + journalpostServices: ResourceByDiscriminator, ): HendelserProducer { return HendelserProducer( journalpostServices.get(Discriminator.SERVICE_USER), kafkaTemplate, objectMapper, topic, - saksbehandlerInfoManager + saksbehandlerInfoManager, ) } @@ -62,7 +62,7 @@ class BidragDokumentArkivKafkaConfig { LOGGER.info( "Initializing Kafka errorhandler with backoffpolicy {}, maxRetry={}", backoffPolicy, - maxRetry + maxRetry, ) val errorHandler = DefaultErrorHandler( { rec: ConsumerRecord<*, *>, e: Exception? -> @@ -78,10 +78,10 @@ class BidragDokumentArkivKafkaConfig { topic, offset, value, - e + e, ) }, - backoffPolicy + backoffPolicy, ) errorHandler.addNotRetryableExceptions(JournalpostHarIkkeKommetIRetur::class.java) return errorHandler @@ -90,7 +90,7 @@ class BidragDokumentArkivKafkaConfig { @Bean fun oppgaveKafkaListenerContainerFactory( oppgaveConsumerFactory: ConsumerFactory, - defaultErrorHandler: DefaultErrorHandler + defaultErrorHandler: DefaultErrorHandler, ): ConcurrentKafkaListenerContainerFactory { val factory = ConcurrentKafkaListenerContainerFactory() factory.consumerFactory = oppgaveConsumerFactory @@ -109,7 +109,7 @@ class BidragDokumentArkivKafkaConfig { @Value("\${KAFKA_KEYSTORE_PATH}") keystorePath: String, @Value("\${KAFKA_TRUSTSTORE_PATH}") trustStorePath: String, @Value("\${KAFKA_CREDSTORE_PASSWORD}") credstorePassword: String, - environment: Environment + environment: Environment, ): ConsumerFactory { val props = mutableMapOf() props[ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG] = boostrapServer diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelseListener.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelseListener.kt index 60d9078a..7cceaa51 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelseListener.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelseListener.kt @@ -16,12 +16,12 @@ import org.springframework.stereotype.Service class HendelseListener( private val behandleJournalforingHendelseService: BehandleJournalforingHendelseService, private val behandleOppgaveHendelseService: BehandleOppgaveHendelseService, - private val jsonMapperService: JsonMapperService + private val jsonMapperService: JsonMapperService, ) { @KafkaListener( containerFactory = "oppgaveKafkaListenerContainerFactory", groupId = "\${NAIS_APP_NAME}", - topics = ["\${TOPIC_OPPGAVE_HENDELSE}"] + topics = ["\${TOPIC_OPPGAVE_HENDELSE}"], ) fun lesOppgaveOpprettetHendelse(consumerRecord: ConsumerRecord) { val oppgaveOpprettetHendelse = @@ -32,7 +32,7 @@ class HendelseListener( ) { LOGGER.info("Mottatt retur oppgave opprettet hendelse {}", oppgaveOpprettetHendelse) behandleOppgaveHendelseService.behandleReturOppgaveOpprettetHendelse( - oppgaveOpprettetHendelse + oppgaveOpprettetHendelse, ) } } @@ -50,7 +50,7 @@ class HendelseListener( } LOGGER.info("Mottok journalføringshendelse {}", journalfoeringHendelseRecord) behandleJournalforingHendelseService.behandleJournalforingHendelse( - journalfoeringHendelseRecord + journalfoeringHendelseRecord, ) } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelserProducer.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelserProducer.kt index 73214f41..bf46c9ac 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelserProducer.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/HendelserProducer.kt @@ -23,7 +23,7 @@ open class HendelserProducer( open val kafkaTemplate: KafkaTemplate, open val objectMapper: ObjectMapper, open val topic: String, - open val saksbehandlerInfoManager: SaksbehandlerInfoManager + open val saksbehandlerInfoManager: SaksbehandlerInfoManager, ) { fun publishJournalpostUpdated(journalpostId: Long, saksbehandlersEnhet: String?) { val journalpostHendelse = createJournalpostHendelse(journalpostId, saksbehandlersEnhet) @@ -34,42 +34,36 @@ open class HendelserProducer( publish(journalpostHendelse) } - private fun createJournalpostHendelse( - journalpostId: Long, - saksbehandlersEnhet: String? - ): JournalpostHendelse { + private fun createJournalpostHendelse(journalpostId: Long, saksbehandlersEnhet: String?): JournalpostHendelse { val journalpost = journalpostService.hentJournalpostMedTilknyttedeSaker(journalpostId) ?: throw JournalpostIkkeFunnetException( String.format( "Fant ikke journalpost med id %s", - journalpostId - ) + journalpostId, + ), ) return createJournalpostHendelse(journalpost, saksbehandlersEnhet) } - private fun createJournalpostHendelse( - journalpost: Journalpost, - saksbehandlersEnhet: String? - ): JournalpostHendelse { + private fun createJournalpostHendelse(journalpost: Journalpost, saksbehandlersEnhet: String?): JournalpostHendelse { val saksbehandler = saksbehandlerInfoManager.hentSaksbehandler() .orElse( Optional.ofNullable(journalpost.hentJournalfortAvIdent()) .map { ident: String? -> Saksbehandler(ident, journalpost.journalfortAvNavn) } - .orElse(Saksbehandler(null, "bidrag-dokument-arkiv")) + .orElse(Saksbehandler(null, "bidrag-dokument-arkiv")), ) val saksbehandlerMedEnhet = saksbehandler.tilEnhet(saksbehandlersEnhet) return JournalpostHendelseIntern( journalpost, saksbehandlerMedEnhet, - null + null, ).hentJournalpostHendelse() } @Retryable( value = [Exception::class], maxAttempts = 10, - backoff = Backoff(delay = 1000, maxDelay = 12000, multiplier = 2.0) + backoff = Backoff(delay = 1000, maxDelay = 12000, multiplier = 2.0), ) private fun publish(journalpostHendelse: JournalpostHendelse) { try { @@ -77,7 +71,7 @@ open class HendelserProducer( SECURE_LOGGER.info("Publiserer hendelse {}", message) LOGGER.info( "Publiserer hendelse med journalpostId={}", - journalpostHendelse.journalpostId + journalpostHendelse.journalpostId, ) kafkaTemplate.send(topic, journalpostHendelse.journalpostId, message) } catch (e: JsonProcessingException) { diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/dto/OppgaveKafkaHendelse.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/dto/OppgaveKafkaHendelse.kt index f592806d..873619ea 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/dto/OppgaveKafkaHendelse.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/kafka/dto/OppgaveKafkaHendelse.kt @@ -6,15 +6,14 @@ import java.time.LocalDateTime data class OppgaveKafkaHendelse( val hendelse: Hendelse, val utfortAv: UtfortAv?, - val oppgave: Oppgave + val oppgave: Oppgave, ) { val erOppgaveOpprettetHendelse get() = hendelse.hendelsestype == Hendelse.Hendelsestype.OPPGAVE_OPPRETTET val erOppgaveEndretHendelse get() = hendelse.hendelsestype != Hendelse.Hendelsestype.OPPGAVE_OPPRETTET fun erReturOppgave() = oppgave.kategorisering?.oppgavetype == "RETUR" - fun erTemaBIDEllerFAR(): Boolean = - oppgave.kategorisering?.tema == "BID" || oppgave.kategorisering?.tema == "FAR" + fun erTemaBIDEllerFAR(): Boolean = oppgave.kategorisering?.tema == "BID" || oppgave.kategorisering?.tema == "FAR" val oppgaveId get() = oppgave.oppgaveId val tema get() = oppgave.kategorisering?.tema @@ -24,7 +23,7 @@ data class OppgaveKafkaHendelse( OPPGAVE_OPPRETTET, OPPGAVE_ENDRET, OPPGAVE_FERDIGSTILT, - OPPGAVE_FEILREGISTRERT + OPPGAVE_FEILREGISTRERT, } } @@ -36,13 +35,13 @@ data class OppgaveKafkaHendelse( val tilordning: Tilordning? = null, val kategorisering: Kategorisering? = null, val behandlingsperiode: Behandlingsperiode? = null, - val bruker: Bruker? = null + val bruker: Bruker? = null, ) data class Tilordning( val enhetsnr: String?, val enhetsmappeId: Long?, - val navIdent: String? + val navIdent: String?, ) data class Kategorisering( @@ -50,18 +49,18 @@ data class OppgaveKafkaHendelse( val oppgavetype: String, val behandlingstema: String? = null, val behandlingstype: String? = null, - val prioritet: Prioritet? = null + val prioritet: Prioritet? = null, ) { enum class Prioritet { HOY, NORMAL, - LAV + LAV, } } data class Behandlingsperiode( val aktiv: LocalDate?, - val frist: LocalDate? + val frist: LocalDate?, ) data class Bruker(val ident: String?, val identType: IdentType?) { @@ -69,7 +68,7 @@ data class OppgaveKafkaHendelse( FOLKEREGISTERIDENT, NPID, ORGNR, - SAMHANDLERNR + SAMHANDLERNR, } } } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/security/SaksbehandlerInfoManager.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/security/SaksbehandlerInfoManager.kt index d9920998..a68a4661 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/security/SaksbehandlerInfoManager.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/security/SaksbehandlerInfoManager.kt @@ -10,7 +10,7 @@ import java.util.Optional @Service class SaksbehandlerInfoManager( private val bidragOrganisasjonConsumer: BidragOrganisasjonConsumer, - private val oidcTokenManager: OidcTokenManager + private val oidcTokenManager: OidcTokenManager, ) { fun hentSaksbehandlerBrukerId(): String? { return try { diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/AvvikService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/AvvikService.kt index 1bdec38c..63d91707 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/AvvikService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/AvvikService.kt @@ -60,7 +60,7 @@ class AvvikService( val opprettJournalpostService: OpprettJournalpostService, dokarkivConsumers: ResourceByDiscriminator, personConsumers: ResourceByDiscriminator, - journalpostService: ResourceByDiscriminator + journalpostService: ResourceByDiscriminator, ) { private final val journalpostService: JournalpostService private final val dokarkivConsumer: DokarkivConsumer @@ -82,17 +82,14 @@ class AvvikService( ?: throw JournalpostIkkeFunnetException("Fant ikke journalpost med id lik " + behandleAvvikRequest.journalpostId) } - fun behandleAvvik( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ): BehandleAvvikshendelseResponse { + fun behandleAvvik(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern): BehandleAvvikshendelseResponse { if (!erGyldigAvviksBehandling(journalpost, avvikshendelseIntern.avvikstype)) { throw UgyldigAvvikException( String.format( "Ikke gyldig avviksbehandling %s for journalpost %s", avvikshendelseIntern.avvikstype, - avvikshendelseIntern.journalpostId - ) + avvikshendelseIntern.journalpostId, + ), ) } when (avvikshendelseIntern.avvikstype) { @@ -101,12 +98,12 @@ class AvvikService( AvvikType.BESTILL_RESKANNING -> bestillReskanning(journalpost, avvikshendelseIntern) AvvikType.KOPIER_FRA_ANNEN_FAGOMRADE -> kopierFraAnnenFagomrade( journalpost, - avvikshendelseIntern + avvikshendelseIntern, ) AvvikType.OVERFOR_TIL_ANNEN_ENHET -> overforJournalpostTilEnhet( journalpost, - avvikshendelseIntern.enhetsnummerNytt + avvikshendelseIntern.enhetsnummerNytt, ) AvvikType.ENDRE_FAGOMRADE -> endreFagomrade(journalpost, avvikshendelseIntern) @@ -116,7 +113,7 @@ class AvvikService( AvvikType.REGISTRER_RETUR -> registrerRetur(journalpost, avvikshendelseIntern) AvvikType.BESTILL_NY_DISTRIBUSJON -> bestillNyDistribusjon( journalpost, - avvikshendelseIntern + avvikshendelseIntern, ) AvvikType.MANGLER_ADRESSE -> manglerAdresse(journalpost) @@ -131,7 +128,7 @@ class AvvikService( saksbehandlerInfoManager.hentSaksbehandlerBrukerId(), avvikshendelseIntern.saksbehandlersEnhet, avvikshendelseIntern.beskrivelse, - avvikshendelseIntern + avvikshendelseIntern, ) return BehandleAvvikshendelseResponse(avvikshendelseIntern.avvikstype) } @@ -140,15 +137,12 @@ class AvvikService( if (journalpost.isInngaaendeDokument()) { hendelserProducer.publishJournalpostUpdated( journalpost.hentJournalpostIdLong()!!, - enhet + enhet, ) } } - private fun bestillSplitting( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + private fun bestillSplitting(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { if (avvikshendelseIntern.beskrivelse.isNullOrEmpty()) { throw UgyldigAvvikException("Avvik bestill splitting må inneholde beskrivelse") } @@ -158,8 +152,8 @@ class AvvikService( BestillSplittingoppgaveRequest( journalpost, saksbehandler, - avvikshendelseIntern.beskrivelse - ) + avvikshendelseIntern.beskrivelse, + ), ) dokarkivConsumer.feilregistrerSakstilknytning(journalpost.hentJournalpostIdLong()) } else { @@ -167,24 +161,21 @@ class AvvikService( oppgaveService.leggTilKommentarPaaJournalforingsoppgave( journalpost, saksbehandler, - beskrivelse + beskrivelse, ) overforJournalpostTilEnhet(journalpost, OppgaveEnhet.FAGPOST) } } - private fun bestillReskanning( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + private fun bestillReskanning(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { val saksbehandler = hentSaksbehandler(avvikshendelseIntern.saksbehandlersEnhet!!) if (journalpost.isStatusJournalfort()) { oppgaveService.opprettOppgaveTilFagpost( BestillReskanningOppgaveRequest( journalpost, saksbehandler, - avvikshendelseIntern.beskrivelse - ) + avvikshendelseIntern.beskrivelse, + ), ) dokarkivConsumer.feilregistrerSakstilknytning(journalpost.hentJournalpostIdLong()) } else { @@ -192,24 +183,21 @@ class AvvikService( oppgaveService.leggTilKommentarPaaJournalforingsoppgave( journalpost, saksbehandler, - beskrivelse + beskrivelse, ) overforJournalpostTilEnhet(journalpost, OppgaveEnhet.FAGPOST) } } - private fun bestillOriginal( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + private fun bestillOriginal(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { val saksbehandler = hentSaksbehandler(avvikshendelseIntern.saksbehandlersEnhet!!) oppgaveService.opprettOppgaveTilFagpost( BestillOriginalOppgaveRequest( journalpost, avvikshendelseIntern.enhetsnummer, saksbehandler, - avvikshendelseIntern.beskrivelse - ) + avvikshendelseIntern.beskrivelse, + ), ) dokarkivConsumer.endre(OppdaterOriginalBestiltFlagg(journalpost)) } @@ -219,8 +207,8 @@ class AvvikService( dokarkivConsumer.endre( OverforEnhetRequest( journalpost.hentJournalpostIdLong()!!, - enhet - ) + enhet, + ), ) } } @@ -231,10 +219,7 @@ class AvvikService( .orElseGet { SaksbehandlerMedEnhet(Saksbehandler(), enhet) } } - fun kopierFraAnnenFagomrade( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + fun kopierFraAnnenFagomrade(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { if (journalpost.isUtgaaendeDokument()) { throw UgyldigAvvikException("Kan ikke kopiere en utgående dokument fra annen fagområde") } @@ -270,14 +255,14 @@ class AvvikService( dokumentvarianter = if (dokumentByte != null) { listOf( opprettDokumentVariant( - dokumentByte = dokumentByte - ) + dokumentByte = dokumentByte, + ), ) } else { emptyList() - } + }, ) - } + }, ) } @@ -285,24 +270,24 @@ class AvvikService( request, avvikshendelseIntern.knyttTilSaker, journalpost.hentJournalpostIdLong(), - skalFerdigstilles = true + skalFerdigstilles = true, ) LOGGER.info( "Kopiert journalpost {} til Bidrag, ny journalpostId {}", journalpost.journalpostId, - journalpostId + journalpostId, ) oppgaveService.ferdigstillVurderDokumentOppgaver( journalpost.hentJournalpostIdLong()!!, - avvikshendelseIntern.saksbehandlersEnhet!! + avvikshendelseIntern.saksbehandlersEnhet!!, ) } fun farskapUtelukket(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { dokarkivConsumer.endre( avvikshendelseIntern.toLeggTiLFarskapUtelukketTilTittelRequest( - journalpost - ) + journalpost, + ), ) } @@ -310,17 +295,14 @@ class AvvikService( oppdaterDistribusjonsInfoIngenDistribusjon(journalpost) } - fun bestillNyDistribusjon( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + fun bestillNyDistribusjon(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { LOGGER.info("Bestiller ny distribusjon for journalpost {}", journalpost.journalpostId) if (avvikshendelseIntern.adresse == null) { throw UgyldigAvvikException("Adresse må settes ved bestilling av ny distribusjon") } distribuerJournalpostService.bestillNyDistribusjon( journalpost, - avvikshendelseIntern.adresse + avvikshendelseIntern.adresse, ) } @@ -347,19 +329,16 @@ class AvvikService( fjern sakstilknytning true }, originalJournalpostId = journalpost.hentJournalpostIdLong(), - skalFerdigstilles = false + skalFerdigstilles = false, ) } - private fun knyttTilSakPaaNyttFagomrade( - avvikshendelseIntern: AvvikshendelseIntern, - journalpost: Journalpost - ) { + private fun knyttTilSakPaaNyttFagomrade(avvikshendelseIntern: AvvikshendelseIntern, journalpost: Journalpost) { val saksnummer = journalpost.sak!!.fagsakId!! hentFeilregistrerteDupliserteJournalposterMedSakOgTema( saksnummer, avvikshendelseIntern.nyttFagomrade, - journalpost + journalpost, ) .findFirst() .ifPresentOrElse( @@ -368,15 +347,15 @@ class AvvikService( oppdater( OpphevEndreFagomradeJournalfortJournalpostRequest( jp.hentJournalpostIdLong()!!, - jp - ) + jp, + ), ) - } + }, ) { endreJournalpostService.tilknyttTilSak( saksnummer, avvikshendelseIntern.nyttFagomrade, - journalpost + journalpost, ) } } @@ -384,7 +363,7 @@ class AvvikService( private fun hentFeilregistrerteDupliserteJournalposterMedSakOgTema( saksnummer: String, tema: String, - journalpost: Journalpost + journalpost: Journalpost, ): Stream { return journalpostService.finnJournalposterForSaksnummer(saksnummer, listOf(tema)).stream() .filter { obj: Journalpost -> obj.isStatusFeilregistrert() } @@ -398,10 +377,7 @@ class AvvikService( } } - fun endreFagomradeJournalfortJournalpost( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + fun endreFagomradeJournalfortJournalpost(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { if (journalpost.isTemaEqualTo(avvikshendelseIntern.nyttFagomrade)) { return } @@ -421,15 +397,12 @@ class AvvikService( endreFagomradeMottattJournalpost(journalpost, avvikshendelseIntern) oppgaveService.ferdigstillVurderDokumentOppgaver( journalpost.hentJournalpostIdLong()!!, - avvikshendelseIntern.saksbehandlersEnhet!! + avvikshendelseIntern.saksbehandlersEnhet!!, ) } } - private fun endreFagomradeMottattJournalpost( - journalpost: Journalpost, - avvikshendelseIntern: AvvikshendelseIntern - ) { + private fun endreFagomradeMottattJournalpost(journalpost: Journalpost, avvikshendelseIntern: AvvikshendelseIntern) { if (journalpost.hasSak()) { oppdater(avvikshendelseIntern.toEndreFagomradeOgKnyttTilSakRequest(journalpost.bruker!!)) } else { @@ -450,8 +423,8 @@ class AvvikService( RegistrerReturRequest( journalpost.hentJournalpostIdLong()!!, returDato, - tilleggsOpplysninger - ) + tilleggsOpplysninger, + ), ) } @@ -459,19 +432,19 @@ class AvvikService( // Journalfør på GENERELL_SAK og feilfør sakstilknytning validateTrue( journalpost.bruker != null, - AvvikDetaljException("Kan ikke trekke journalpost uten bruker") + AvvikDetaljException("Kan ikke trekke journalpost uten bruker"), ) validateTrue( journalpost.tema != null, - AvvikDetaljException("Kan ikke trekke journalpost uten tilhørende fagområde") + AvvikDetaljException("Kan ikke trekke journalpost uten tilhørende fagområde"), ) knyttTilGenerellSak(avvikshendelseIntern, journalpost) klargjorForFerdigstilling(journalpost) dokarkivConsumer.ferdigstill( FerdigstillJournalpostRequest( avvikshendelseIntern.journalpostId, - avvikshendelseIntern.saksbehandlersEnhet!! - ) + avvikshendelseIntern.saksbehandlersEnhet!!, + ), ) leggTilBegrunnelsePaaTittel(avvikshendelseIntern, journalpost) feilregistrerSakstilknytning(avvikshendelseIntern.journalpostId) @@ -489,8 +462,8 @@ class AvvikService( dokarkivConsumer.endre( LagreAvsenderNavnRequest( journalpost.hentJournalpostIdLong()!!, - brukerNavn!! - ) + brukerNavn!!, + ), ) journalpost.avsenderMottaker = AvsenderMottaker(brukerNavn, null, null) } @@ -500,19 +473,16 @@ class AvvikService( oppdater( avvikshendelseIntern.toKnyttTilGenerellSakRequest( journalpost.tema!!, - journalpost.bruker!! - ) + journalpost.bruker!!, + ), ) } - fun leggTilBegrunnelsePaaTittel( - avvikshendelseIntern: AvvikshendelseIntern, - journalpost: Journalpost? - ) { + fun leggTilBegrunnelsePaaTittel(avvikshendelseIntern: AvvikshendelseIntern, journalpost: Journalpost?) { if (Strings.isNotEmpty(avvikshendelseIntern.beskrivelse)) { validateTrue( avvikshendelseIntern.beskrivelse!!.length < 100, - AvvikDetaljException("Beskrivelse kan ikke være lengre enn 100 tegn") + AvvikDetaljException("Beskrivelse kan ikke være lengre enn 100 tegn"), ) oppdater(avvikshendelseIntern.toLeggTilBegrunnelsePaaTittelRequest(journalpost!!)) } @@ -542,9 +512,9 @@ class AvvikService( dokarkivConsumer.oppdaterDistribusjonsInfo( journalpostId, false, - JournalpostUtsendingKanal.INGEN_DISTRIBUSJON + JournalpostUtsendingKanal.INGEN_DISTRIBUSJON, ) - } + }, ) } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostService.kt index 4d9a4d34..6b265c05 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostService.kt @@ -52,7 +52,7 @@ class DistribuerJournalpostService( val dokdistFordelingConsumer: DokdistFordelingConsumer, val saksbehandlerInfoManager: SaksbehandlerInfoManager, val dokdistKanalConsumer: DokdistKanalConsumer, - final val meterRegistry: MeterRegistry + final val meterRegistry: MeterRegistry, ) { private final val journalpostService: JournalpostService private final val personConsumer: PersonConsumer @@ -79,7 +79,7 @@ class DistribuerJournalpostService( request.gjelderId, request.mottakerId, request.tema, - request.forsendelseStoerrelse + request.forsendelseStoerrelse, ) SECURE_LOGGER.info("Hentet kanal ${kanal.distribusjonskanal} for forespørsel $request") return kanal @@ -90,8 +90,8 @@ class DistribuerJournalpostService( BestemDistribusjonKanalRequest( journalpost.hentAvsenderMottakerId(), journalpost.hentGjelderId()!!, - journalpost.tema ?: "BID" - ) + journalpost.tema ?: "BID", + ), ) } @@ -115,25 +115,22 @@ class DistribuerJournalpostService( ?: utsendingsinfo?.smsVarselSendt?.varslingstekst ?: utsendingsinfo?.epostVarselSendt?.varslingstekst, tittel = utsendingsinfo?.sisteVarselSendt?.tittel - ?: utsendingsinfo?.epostVarselSendt?.tittel + ?: utsendingsinfo?.epostVarselSendt?.tittel, ), distribuertAvIdent = it.hentDistribuertAvIdent(), distribuertDato = it.hentDatoEkspedert() ?: it.hentDatoDokument(), - bestillingId = it.hentBestillingId() + bestillingId = it.hentBestillingId(), ) } } - fun bestillNyDistribusjon( - journalpost: Journalpost, - distribuerTilAdresse: DistribuerTilAdresse? - ) { + fun bestillNyDistribusjon(journalpost: Journalpost, distribuerTilAdresse: DistribuerTilAdresse?) { if (journalpost.tilleggsopplysninger.isNyDistribusjonBestilt()) { throw UgyldigDistribusjonException( String.format( "Ny distribusjon er allerede bestilt for journalpost %s", - journalpost.journalpostId - ) + journalpost.journalpostId, + ), ) } validerAdresse(distribuerTilAdresse) @@ -148,19 +145,19 @@ class DistribuerJournalpostService( val (journalpostId) = opprettJournalpostService.opprettJournalpost( request, originalJournalpostId = journalpost.hentJournalpostIdLong(), - skalFerdigstilles = true + skalFerdigstilles = true, ) distribuerJournalpost( journalpostId!!.toLong(), null, - DistribuerJournalpostRequestInternal(distribuerTilAdresse) + DistribuerJournalpostRequestInternal(distribuerTilAdresse), ) val journalpostEtter = hentJournalpost(journalpost.hentJournalpostIdLong()!!) endreJournalpostService.lagreJournalpost( OppdaterFlaggNyDistribusjonBestiltRequest( journalpost.hentJournalpostIdLong()!!, - journalpostEtter - ) + journalpostEtter, + ), ) } @@ -171,8 +168,8 @@ class DistribuerJournalpostService( } endreJournalpostService.lagreJournalpost( LagreReturDetaljForSisteReturRequest( - journalpost - ) + journalpost, + ), ) } } @@ -180,7 +177,7 @@ class DistribuerJournalpostService( fun distribuerJournalpost( journalpostId: Long, batchId: String?, - distribuerJournalpostRequest: DistribuerJournalpostRequestInternal + distribuerJournalpostRequest: DistribuerJournalpostRequestInternal, ): DistribuerJournalpostResponse { val journalpost = hentJournalpost(journalpostId) journalpostService.populerMedTilknyttedeSaker(journalpost) @@ -188,7 +185,7 @@ class DistribuerJournalpostService( LOGGER.warn( "Distribusjon er allerede bestillt for journalpostid {}{}. Stopper videre behandling", journalpostId, - if (batchId != null) String.format(" med batchId %s", batchId) else "" + if (batchId != null) String.format(" med batchId %s", batchId) else "", ) return DistribuerJournalpostResponse("JOARK-$journalpostId", null) } @@ -210,7 +207,7 @@ class DistribuerJournalpostService( if (distribusjonKanal.distribusjonskanal == DistribusjonsKanal.PRINT) { hentOgValiderAdresse( distribuerJournalpostRequest, - journalpost + journalpost, ) } else { null @@ -220,7 +217,8 @@ class DistribuerJournalpostService( val distribuerResponse = dokdistFordelingConsumer.distribuerJournalpost(journalpost, batchId, adresse) LOGGER.info( - "Bestillte distribusjon av journalpost $journalpostId med bestillingsId ${distribuerResponse.bestillingsId}, antall dokumenter ${journalpost.dokumenter.size} og kanal ${distribusjonKanal.distribusjonskanal}(${distribusjonKanal.regel}-${distribusjonKanal.regelBegrunnelse})." + "Bestillte distribusjon av journalpost $journalpostId med bestillingsId ${distribuerResponse.bestillingsId}, " + + "antall dokumenter ${journalpost.dokumenter.size} og kanal ${distribusjonKanal.distribusjonskanal}(${distribusjonKanal.regel}-${distribusjonKanal.regelBegrunnelse}).", ) // Distribusjonsløpet oppdaterer journalpost og overskriver alt av tilleggsopplysninger. Hent journalpost på nytt for å unngå overskrive noe som distribusjon har lagret @@ -235,11 +233,11 @@ class DistribuerJournalpostService( val journalpostEtter = hentJournalpost(journalpostId) val datoDokument = journalpostFør.hentDatoDokument()?.toString() LOGGER.info( - "Dokumentdato ($datoDokument) til journalpost $journalpostId er ikke samme som dato distribusjon ble bestilt. Oppdaterer dokumentdato til i dag" + "Dokumentdato ($datoDokument) til journalpost $journalpostId er ikke samme som dato distribusjon ble bestilt. Oppdaterer dokumentdato til i dag", ) endreJournalpostService.oppdaterDokumentdatoTilIdag( journalpostEtter.hentJournalpostIdLong()!!, - journalpostEtter + journalpostEtter, ) } } @@ -257,8 +255,8 @@ class DistribuerJournalpostService( LeggTilBeskjedPåTittel( journalpostEtter.hentJournalpostIdLong()!!, journalpostEtter, - "dokumentet er sendt per post med vedlegg" - ) + "dokumentet er sendt per post med vedlegg", + ), ) } } @@ -268,7 +266,7 @@ class DistribuerJournalpostService( journalpostFør: Journalpost, adresse: DistribuerTilAdresse? = null, erLokalUtskrift: Boolean = false, - bestemKanalResponse: BestemKanalResponse? = null + bestemKanalResponse: BestemKanalResponse? = null, ) { val journalpostEtter = hentJournalpost(journalpostId) leggTilEksisterendeTilleggsopplysninger(journalpostEtter, journalpostFør) @@ -279,26 +277,23 @@ class DistribuerJournalpostService( val saksbehandlerId = saksbehandlerInfoManager.hentSaksbehandlerBrukerId() saksbehandlerId?.run { journalpostEtter.tilleggsopplysninger.setDistribuertAvIdent( - saksbehandlerId + saksbehandlerId, ) } endreJournalpostService.oppdaterJournalpostTilleggsopplysninger( journalpostId, - journalpostEtter + journalpostEtter, ) } - private fun leggTilEksisterendeTilleggsopplysninger( - journalpostEtter: Journalpost, - journalpostFør: Journalpost - ) { + private fun leggTilEksisterendeTilleggsopplysninger(journalpostEtter: Journalpost, journalpostFør: Journalpost) { journalpostEtter.tilleggsopplysninger .addAll( journalpostFør.tilleggsopplysninger.filter { !journalpostEtter.tilleggsopplysninger.contains( - it + it, ) - } + }, ) } @@ -308,15 +303,15 @@ class DistribuerJournalpostService( throw JournalpostIkkeFunnetException( String.format( "Fant ingen journalpost med id %s", - journalpostId - ) + journalpostId, + ), ) } } private fun hentOgValiderAdresse( distribuerJournalpostRequestInternal: DistribuerJournalpostRequestInternal, - journalpost: Journalpost + journalpost: Journalpost, ): DistribuerTilAdresse? { val adresse = hentAdresse(distribuerJournalpostRequestInternal, journalpost) if (adresse != null) { @@ -329,14 +324,14 @@ class DistribuerJournalpostService( private fun hentAdresse( distribuerJournalpostRequestInternal: DistribuerJournalpostRequestInternal, - journalpost: Journalpost + journalpost: Journalpost, ): DistribuerTilAdresse? { if (distribuerJournalpostRequestInternal.hasAdresse()) { return distribuerJournalpostRequestInternal.getAdresse() } LOGGER.info( "Distribusjon av journalpost bestilt uten adresse. Henter adresse for mottaker. JournalpostId {}", - journalpost.journalpostId + journalpost.journalpostId, ) val adresseResponse = personConsumer.hentAdresse(journalpost.hentAvsenderMottakerId()) if (Objects.isNull(adresseResponse)) { @@ -349,7 +344,7 @@ class DistribuerJournalpostService( adresseResponse.adresselinje3?.verdi, adresseResponse.land.verdi, adresseResponse.postnummer?.verdi, - adresseResponse.poststed?.verdi + adresseResponse.poststed?.verdi, ) } @@ -357,7 +352,7 @@ class DistribuerJournalpostService( endreJournalpostService.oppdaterDistribusjonsInfo( journalpostId, true, - JournalpostUtsendingKanal.L + JournalpostUtsendingKanal.L, ) } @@ -367,16 +362,13 @@ class DistribuerJournalpostService( ?: throw JournalpostIkkeFunnetException( String.format( "Fant ingen journalpost med id %s", - journalpostId - ) + journalpostId, + ), ) validerKanDistribueres(journalpost) } - private fun lagreAdresse( - distribuerTilAdresse: DistribuerTilAdresse?, - journalpost: Journalpost - ) { + private fun lagreAdresse(distribuerTilAdresse: DistribuerTilAdresse?, journalpost: Journalpost) { if (distribuerTilAdresse != null) { val mottakerAdresseDO = mapToAdresseDO(distribuerTilAdresse) if (journalpost.isUtgaaendeDokument() && mottakerAdresseDO != null) { @@ -393,18 +385,14 @@ class DistribuerJournalpostService( adresselinje3 = adresse.adresselinje3, land = adresse.land!!, poststed = adresse.poststed, - postnummer = adresse.postnummer + postnummer = adresse.postnummer, ) } else { null } } - private fun measureDistribution( - journalpost: Journalpost, - batchId: String?, - lokalUtskrift: Boolean = false - ) { + private fun measureDistribution(journalpost: Journalpost, batchId: String?, lokalUtskrift: Boolean = false) { try { val kanal = if (lokalUtskrift) "LOKAL_UTSKRIFT" else hentDistribusjonKanal(journalpost).distribusjonskanal.name @@ -414,7 +402,7 @@ class DistribuerJournalpostService( if (Strings.isNullOrEmpty(batchId)) "NONE" else batchId, "enhet", journalpost.journalforendeEnhet, "tema", journalpost.tema, - "kanal", kanal + "kanal", kanal, ).increment() distributionAntallDokumenter.record(journalpost.dokumenter.size.toDouble()) diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/DokumentService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/DokumentService.kt index 2d93131e..8a5b22e9 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/DokumentService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/DokumentService.kt @@ -15,7 +15,7 @@ import org.springframework.stereotype.Service @Service class DokumentService( safConsumers: ResourceByDiscriminator, - journalpostServices: ResourceByDiscriminator + journalpostServices: ResourceByDiscriminator, ) { private val safConsumer: SafConsumer private val journalpostService: JournalpostService @@ -30,12 +30,7 @@ class DokumentService( return safConsumer.hentDokument(journalpostId, java.lang.Long.valueOf(dokumentReferanse)) } - fun tilDokumentMetadata( - journalStatus: JournalStatus?, - dokumentReferanse: String?, - journalpostId: Long?, - tittel: String? - ) = DokumentMetadata( + fun tilDokumentMetadata(journalStatus: JournalStatus?, dokumentReferanse: String?, journalpostId: Long?, tittel: String?) = DokumentMetadata( arkivsystem = DokumentArkivSystemDto.JOARK, dokumentreferanse = dokumentReferanse, journalpostId = "JOARK-$journalpostId", @@ -45,13 +40,10 @@ class DokumentService( JournalStatus.AVBRUTT, JournalStatus.FEILREGISTRERT, JournalStatus.UTGAAR -> DokumentStatusDto.AVBRUTT else -> DokumentStatusDto.FERDIGSTILT }, - tittel = tittel + tittel = tittel, ) - fun hentDokumentMetadata( - journalpostId: Long? = null, - dokumentReferanse: String? - ): List { + fun hentDokumentMetadata(journalpostId: Long? = null, dokumentReferanse: String?): List { if (journalpostId == null && dokumentReferanse != null) { return listOf( journalpostService.finnTilknyttedeJournalposter(dokumentReferanse) @@ -60,9 +52,9 @@ class DokumentService( it.journalstatus, dokumentReferanse, it.journalpostId, - it.tittel + it.tittel, ) - }.first() + }.first(), ) } @@ -72,7 +64,7 @@ class DokumentService( journalpost.journalstatus, it.dokumentInfoId, journalpostId, - it.tittel + it.tittel, ) }?.filter { dokumentReferanse.isNullOrEmpty() || it.dokumentreferanse == dokumentReferanse } ?: emptyList() diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/EndreJournalpostService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/EndreJournalpostService.kt index 0cfafa56..0281d884 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/EndreJournalpostService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/EndreJournalpostService.kt @@ -31,7 +31,7 @@ class EndreJournalpostService( private val dokarkivConsumer: DokarkivConsumer, private val dokarkivKnyttTilSakConsumer: DokarkivKnyttTilSakConsumer, private val hendelserProducer: HendelserProducer, - private val saksbehandlerInfoManager: SaksbehandlerInfoManager + private val saksbehandlerInfoManager: SaksbehandlerInfoManager, ) { fun endre(journalpostId: Long, endreJournalpostCommand: EndreJournalpostCommandIntern) { var journalpost = hentJournalpost(journalpostId) @@ -48,12 +48,12 @@ class EndreJournalpostService( private fun publiserJournalpostEndretHendelse( journalpost: Journalpost, journalpostId: Long, - endreJournalpostCommand: EndreJournalpostCommandIntern + endreJournalpostCommand: EndreJournalpostCommandIntern, ) { if (journalpost.isInngaaendeDokument()) { hendelserProducer.publishJournalpostUpdated( journalpostId, - endreJournalpostCommand.enhet + endreJournalpostCommand.enhet, ) } } @@ -62,11 +62,7 @@ class EndreJournalpostService( return dokarkivConsumer.endre(oppdaterJournalpostRequest) } - private fun lagreJournalpost( - journalpostId: Long, - endreJournalpostCommand: EndreJournalpostCommandIntern, - journalpost: Journalpost - ) { + private fun lagreJournalpost(journalpostId: Long, endreJournalpostCommand: EndreJournalpostCommandIntern, journalpost: Journalpost) { val oppdaterJournalpostRequest = LagreJournalpostRequest(journalpostId, endreJournalpostCommand, journalpost) lagreJournalpost(oppdaterJournalpostRequest) @@ -75,10 +71,7 @@ class EndreJournalpostService( } } - private fun journalfoerJournalpostNarMottaksregistrert( - endreJournalpostCommand: EndreJournalpostCommandIntern, - journalpost: Journalpost - ) { + private fun journalfoerJournalpostNarMottaksregistrert(endreJournalpostCommand: EndreJournalpostCommandIntern, journalpost: Journalpost) { if (endreJournalpostCommand.skalJournalfores() && journalpost.isStatusMottatt()) { val journalpostId = journalpost.hentJournalpostIdLong() journalfoerJournalpost(journalpostId, endreJournalpostCommand.enhet, journalpost) @@ -86,33 +79,27 @@ class EndreJournalpostService( } } - fun lagreSaksbehandlerIdentForJournalfortJournalpost( - journalpost: Journalpost, - saksbehandlerIdent: String? - ) { + fun lagreSaksbehandlerIdentForJournalfortJournalpost(journalpost: Journalpost, saksbehandlerIdent: String?) { try { lagreJournalpost( LagreJournalfortAvIdentRequest( journalpost.hentJournalpostIdLong()!!, journalpost, - (saksbehandlerIdent ?: saksbehandlerInfoManager.hentSaksbehandlerBrukerId())!! - ) + (saksbehandlerIdent ?: saksbehandlerInfoManager.hentSaksbehandlerBrukerId())!!, + ), ) } catch (e: Exception) { throw LagreSaksbehandlerIdentForJournalfortJournalpostFeilet( String.format( "Lagring av saksbehandler ident for journalført journalpost %s feilet", - journalpost.journalpostId + journalpost.journalpostId, ), - e + e, ) } } - private fun tilknyttSakerTilJournalfoertJournalpost( - endreJournalpostCommand: EndreJournalpostCommandIntern, - journalpost: Journalpost - ) { + private fun tilknyttSakerTilJournalfoertJournalpost(endreJournalpostCommand: EndreJournalpostCommandIntern, journalpost: Journalpost) { if (journalpost.kanTilknytteSaker()) { journalpostService.populerMedTilknyttedeSaker(journalpost) endreJournalpostCommand.hentTilknyttetSaker().stream() @@ -122,9 +109,9 @@ class EndreJournalpostService( Consumer { saksnummer: String? -> tilknyttTilSak( saksnummer, - journalpost + journalpost, ) - } + }, ) } } @@ -138,33 +125,26 @@ class EndreJournalpostService( KnyttTilSakRequest(saksnummer!!, journalpost, tema) val (nyJournalpostId) = dokarkivKnyttTilSakConsumer.knyttTilSak( journalpost.hentJournalpostIdLong(), - knyttTilAnnenSakRequest + knyttTilAnnenSakRequest, ) LOGGER.info( "Tilknyttet journalpost {} til sak {} med ny journalpostId {} og tema {}", journalpost.journalpostId, saksnummer, nyJournalpostId, - tema + tema, ) journalpost.leggTilTilknyttetSak(saksnummer) } - private fun journalfoerJournalpost( - journalpostId: Long?, - enhet: String?, - journalpost: Journalpost - ) { + private fun journalfoerJournalpost(journalpostId: Long?, enhet: String?, journalpost: Journalpost) { val journalforRequest = FerdigstillJournalpostRequest(journalpostId!!, enhet!!) dokarkivConsumer.ferdigstill(journalforRequest) LOGGER.info("Journalpost med id $journalpostId er journalført") lagreSaksbehandlerIdentForJournalfortJournalpost(journalpost, null) } - fun oppdaterJournalpostDistribusjonBestiltStatus( - journalpostId: Long, - journalpost: Journalpost - ) { + fun oppdaterJournalpostDistribusjonBestiltStatus(journalpostId: Long, journalpost: Journalpost) { lagreJournalpost(OppdaterJournalpostDistribusjonsInfoRequest(journalpostId, journalpost)) } @@ -182,15 +162,11 @@ class EndreJournalpostService( ?: throw JournalpostIkkeFunnetException("Kunne ikke finne journalpost med id: $journalpostId") } - fun oppdaterDistribusjonsInfo( - journalpostId: Long?, - settStatusEkspedert: Boolean, - utsendingsKanal: JournalpostUtsendingKanal? - ) { + fun oppdaterDistribusjonsInfo(journalpostId: Long?, settStatusEkspedert: Boolean, utsendingsKanal: JournalpostUtsendingKanal?) { dokarkivConsumer.oppdaterDistribusjonsInfo( journalpostId, settStatusEkspedert, - utsendingsKanal + utsendingsKanal, ) } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/JournalpostService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/JournalpostService.kt index eae62b3f..1a2260ae 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/JournalpostService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/JournalpostService.kt @@ -16,7 +16,7 @@ import java.util.Optional class JournalpostService( private val safConsumer: SafConsumer, - private val personConsumer: PersonConsumer + private val personConsumer: PersonConsumer, ) { fun hentJournalpost(journalpostId: Long): Journalpost? { return hentJournalpost(journalpostId, null) @@ -26,28 +26,21 @@ class JournalpostService( return hentJournalpost(journalpostId)?.let { populerMedTilknyttedeSaker(it) } } - fun hentJournalpostMedFnrOgTilknyttedeSaker( - journalpostId: Long, - saksnummer: String? - ): Optional { + fun hentJournalpostMedFnrOgTilknyttedeSaker(journalpostId: Long, saksnummer: String?): Optional { return hentJournalpostMedFnr(journalpostId, saksnummer)?.let { Optional.ofNullable( - populerMedTilknyttedeSaker(it) + populerMedTilknyttedeSaker(it), ) } ?: Optional.empty() } - fun List.inneholderBidragFagomrader() = - this.isEmpty() || this.hentIkkeBidragFagomrader().isEmpty() + fun List.inneholderBidragFagomrader() = this.isEmpty() || this.hentIkkeBidragFagomrader().isEmpty() fun List.hentIkkeBidragFagomrader() = this.filter { it != "BID" && it != "FAR" } - fun finnJournalposter( - saksnummer: String, - fagomrade: List = emptyList() - ): List { + fun finnJournalposter(saksnummer: String, fagomrade: List = emptyList()): List { if (!fagomrade.inneholderBidragFagomrader()) { kanIkkeHenteJournalMedUgyldigFagomrade( - fagomrade.hentIkkeBidragFagomrader().joinToString(",") + fagomrade.hentIkkeBidragFagomrader().joinToString(","), ) } return finnJournalposterForSaksnummer(saksnummer, fagomrade) @@ -95,10 +88,7 @@ class JournalpostService( return hentJournalpost(journalpostId, saksummer)?.let { konverterAktoerIdTilFnr(it) } } - fun finnJournalposterForSaksnummer( - saksnummer: String, - fagomrade: List = emptyList() - ): List { + fun finnJournalposterForSaksnummer(saksnummer: String, fagomrade: List = emptyList()): List { return safConsumer.finnJournalposter(saksnummer, fagomrade) } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/OppgaveService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/OppgaveService.kt index 113cb49d..2a6bc56b 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/OppgaveService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/OppgaveService.kt @@ -26,14 +26,10 @@ import java.util.function.Consumer class OppgaveService( private val personConsumers: ResourceByDiscriminator, private val oppgaveConsumers: ResourceByDiscriminator, - private val saksbehandlerInfoManager: SaksbehandlerInfoManager + private val saksbehandlerInfoManager: SaksbehandlerInfoManager, ) { - fun leggTilKommentarPaaJournalforingsoppgave( - journalpost: Journalpost, - saksbehandlerMedEnhet: SaksbehandlerMedEnhet, - kommentar: String - ) { + fun leggTilKommentarPaaJournalforingsoppgave(journalpost: Journalpost, saksbehandlerMedEnhet: SaksbehandlerMedEnhet, kommentar: String) { val oppgaver = finnJournalforingOppgaverForJournalpost(journalpost.hentJournalpostIdLong()) oppgaver.filter { it.tildeltEnhetsnr != OppgaveEnhet.FAGPOST }.forEach( Consumer { oppgave: OppgaveData -> @@ -43,11 +39,11 @@ class OppgaveService( oppgave, saksbehandlerMedEnhet.enhetsnummer, saksbehandlerMedEnhet.hentSaksbehandlerInfo(), - kommentar - ) + kommentar, + ), ) LOGGER.info("Journalføringsoppgave ${oppgave.id} for journalpost ${journalpost.journalpostId} ble overført til fagpost") - } + }, ) } @@ -59,13 +55,7 @@ class OppgaveService( opprettOppgave(opprettOppgaveFagpostRequest) } - fun opprettVurderDokumentOppgave( - journalpost: Journalpost, - journalpostId: String, - tildeltEnhetsnr: String, - tema: String, - kommentar: String? - ) { + fun opprettVurderDokumentOppgave(journalpost: Journalpost, journalpostId: String, tildeltEnhetsnr: String, tema: String, kommentar: String?) { val aktorId = hentAktorId(journalpost.hentGjelderId()) opprettOppgave( OpprettVurderDokumentOppgaveRequest( @@ -75,8 +65,8 @@ class OppgaveService( tema, aktorId!!, hentSaksbehandlerMedEnhet(journalpost.journalforendeEnhet), - kommentar - ) + kommentar, + ), ) } @@ -89,7 +79,7 @@ class OppgaveService( LOGGER.info( "Ferdigstiller oppgave {} med oppgavetype {}", oppgaveData.id, - oppgaveData.oppgavetype + oppgaveData.oppgavetype, ) oppgaveConsumers.get(Discriminator.SERVICE_USER) .patchOppgave(FerdigstillOppgaveRequest(oppgaveData, enhetsnr)) @@ -112,7 +102,7 @@ class OppgaveService( .orElseGet { PersonDto( ident = PersonIdent(gjelder), - aktørId = AktørId(gjelder) + aktørId = AktørId(gjelder), ) }.aktørId?.verdi } diff --git a/src/main/java/no/nav/bidrag/dokument/arkiv/service/OpprettJournalpostService.kt b/src/main/java/no/nav/bidrag/dokument/arkiv/service/OpprettJournalpostService.kt index e24da3af..2adf6951 100644 --- a/src/main/java/no/nav/bidrag/dokument/arkiv/service/OpprettJournalpostService.kt +++ b/src/main/java/no/nav/bidrag/dokument/arkiv/service/OpprettJournalpostService.kt @@ -45,7 +45,7 @@ class OpprettJournalpostService( private val saksbehandlerInfoManager: SaksbehandlerInfoManager, private val dokumentService: DokumentService, private val endreJournalpostService: EndreJournalpostService, - private val bidragDokumentConsumer: BidragDokumentConsumer + private val bidragDokumentConsumer: BidragDokumentConsumer, ) { private val dokarkivConsumer: DokarkivConsumer private val safConsumer: SafConsumer @@ -65,33 +65,29 @@ class OpprettJournalpostService( val respons = opprettJournalpost( opprettJournalpostRequest, request.tilknyttSaker, - skalFerdigstilles = false + skalFerdigstilles = false, ) val journalpostId = respons.journalpostId!!.toLong() ferdigstillJournalpost( journalpostId, request.hentJournalførendeEnhet()!!, - request.saksbehandlerIdent + request.saksbehandlerIdent, ) lagreSaksbehandlerIdentOgKnyttFerdigstiltJournalpostTilSaker( journalpostId, request.tilknyttSaker, - request.saksbehandlerIdent + request.saksbehandlerIdent, ) return respons } return opprettJournalpost( opprettJournalpostRequest, request.tilknyttSaker, - skalFerdigstilles = request.skalFerdigstilles + skalFerdigstilles = request.skalFerdigstilles, ) } - private fun ferdigstillJournalpost( - journalpostId: Long, - journalfoerendeEnhet: String, - saksbehandlerIdent: String? - ) { + private fun ferdigstillJournalpost(journalpostId: Long, journalfoerendeEnhet: String, saksbehandlerIdent: String?) { val saksbehandlerNavn = saksbehandlerIdent?.let { saksbehandlerInfoManager.hentSaksbehandler(it) } ?.orElse(null)?.navn @@ -100,8 +96,8 @@ class OpprettJournalpostService( journalpostId = journalpostId, journalfoerendeEnhet = journalfoerendeEnhet, opprettetAvNavn = saksbehandlerNavn, - journalfortAvNavn = saksbehandlerNavn - ) + journalfortAvNavn = saksbehandlerNavn, + ), ) } @@ -109,7 +105,7 @@ class OpprettJournalpostService( _request: JoarkOpprettJournalpostRequest, knyttTilSaker: List = emptyList(), originalJournalpostId: Long?, - skalFerdigstilles: Boolean = false + skalFerdigstilles: Boolean = false, ): OpprettJournalpostResponse { val tilknyttetSak = if (knyttTilSaker.isNotEmpty()) knyttTilSaker[0] else _request.sak?.fagsakId @@ -119,9 +115,9 @@ class OpprettJournalpostService( null } else { JoarkOpprettJournalpostRequest.OpprettJournalpostSak( - tilknyttetSak + tilknyttetSak, ) - } + }, ) request = populerMedDokumenterByteData(request, originalJournalpostId) return opprettJournalpost(request, knyttTilSaker, skalFerdigstilles) @@ -130,12 +126,14 @@ class OpprettJournalpostService( private fun opprettJournalpost( request: JoarkOpprettJournalpostRequest, knyttTilSaker: List = emptyList(), - skalFerdigstilles: Boolean = false + skalFerdigstilles: Boolean = false, ): OpprettJournalpostResponse { validerKanOppretteJournalpost(request, skalFerdigstilles) val response = dokarkivConsumer.opprett(request, skalFerdigstilles) - LOGGER.info("Opprettet ny journalpost ${response.journalpostId} med type=${request.journalpostType} kanal=${request.kanal}, tema=${request.tema}, referanseId=${request.eksternReferanseId} og enhet=${request.journalfoerendeEnhet}") + LOGGER.info( + "Opprettet ny journalpost ${response.journalpostId} med type=${request.journalpostType} kanal=${request.kanal}, tema=${request.tema}, referanseId=${request.eksternReferanseId} og enhet=${request.journalfoerendeEnhet}", + ) SECURE_LOGGER.info("Opprettet ny journalpost {}", response) validerOpprettJournalpostResponse(skalFerdigstilles, response) @@ -143,7 +141,7 @@ class OpprettJournalpostService( if (response.journalpostferdigstilt) { lagreSaksbehandlerIdentOgKnyttFerdigstiltJournalpostTilSaker( response.journalpostId!!, - knyttTilSaker + knyttTilSaker, ) } @@ -151,39 +149,36 @@ class OpprettJournalpostService( journalpostId = response.journalpostId.toString(), dokumenter = response.dokumenter?.map { OpprettDokumentDto(dokumentreferanse = it.dokumentInfoId) - } ?: emptyList() + } ?: emptyList(), ) } private fun lagreSaksbehandlerIdentOgKnyttFerdigstiltJournalpostTilSaker( journalpostId: Long, knyttTilSaker: List, - saksbehandlerIdent: String? = null + saksbehandlerIdent: String? = null, ) { try { val opprettetJournalpost = hentJournalpost(journalpostId) endreJournalpostService.lagreSaksbehandlerIdentForJournalfortJournalpost( opprettetJournalpost, - saksbehandlerIdent + saksbehandlerIdent, ) knyttSakerTilOpprettetJournalpost(opprettetJournalpost, knyttTilSaker) } catch (e: Exception) { LOGGER.error( "Etterbehandling av opprettet journalpost feilet (knytt til flere saker eller lagre saksbehandler ident). Fortsetter behandling da feilen må behandles manuelt.", - e + e, ) } } - private fun validerOpprettJournalpostResponse( - skalFerdigstilles: Boolean, - response: JoarkOpprettJournalpostResponse - ) { + private fun validerOpprettJournalpostResponse(skalFerdigstilles: Boolean, response: JoarkOpprettJournalpostResponse) { if (skalFerdigstilles && !response.journalpostferdigstilt) { val message = String.format( "Kunne ikke journalføre journalpost %s med feilmelding %s", response.journalpostId, - response.melding + response.melding, ) LOGGER.error(message) throw KunneIkkeJournalforeOpprettetJournalpost(message) @@ -198,25 +193,19 @@ class OpprettJournalpostService( } } - private fun knyttSakerTilOpprettetJournalpost( - opprettetJournalpost: Journalpost, - knyttTilSaker: List - ) { + private fun knyttSakerTilOpprettetJournalpost(opprettetJournalpost: Journalpost, knyttTilSaker: List) { knyttTilSaker .stream() .filter { saksnummer: String -> saksnummer != opprettetJournalpost.sak!!.fagsakId } .forEach { saksnummer: String? -> endreJournalpostService.tilknyttTilSak( saksnummer, - opprettetJournalpost + opprettetJournalpost, ) } } - private fun populerMedDokumenterByteData( - request: JoarkOpprettJournalpostRequest, - originalJournalpostId: Long? - ): JoarkOpprettJournalpostRequest { + private fun populerMedDokumenterByteData(request: JoarkOpprettJournalpostRequest, originalJournalpostId: Long?): JoarkOpprettJournalpostRequest { if (originalJournalpostId != null) { return request.copy( dokumenter = request.dokumenter.map { @@ -226,7 +215,7 @@ class OpprettJournalpostService( } else { it } - } + }, ) } return request @@ -286,11 +275,11 @@ class OpprettJournalpostService( }, bruker = JoarkOpprettJournalpostRequest.OpprettJournalpostBruker( id = request.hentGjelderIdent(), - idType = request.hentGjelderType()?.name + idType = request.hentGjelderType()?.name, ), avsenderMottaker = if (request.journalposttype != JournalpostType.NOTAT) { mapMottaker( - request + request, ) } else { null @@ -307,12 +296,12 @@ class OpprettJournalpostService( dokumentvarianter = listOf( opprettDokumentVariant( null, - hentDokument(it) - ) - ) + hentDokument(it), + ), + ), ) }, - tilleggsopplysninger = tilleggsOpplysninger + tilleggsopplysninger = tilleggsOpplysninger, ) } @@ -322,18 +311,18 @@ class OpprettJournalpostService( } ?: dokumentDto.dokumentreferanse?.let { LOGGER.info("Henter dokument bytedata for dokument med tittel ${dokumentDto.tittel} og dokumentreferanse ${dokumentDto.dokumentreferanse}") bidragDokumentConsumer.hentDokument( - it + it, ) } ?: throw HttpClientErrorException( HttpStatus.BAD_REQUEST, - "Fant ikke referanse eller data for dokument med tittel ${dokumentDto.tittel}" + "Fant ikke referanse eller data for dokument med tittel ${dokumentDto.tittel}", ) } private fun mapMottaker(request: OpprettJournalpostRequest): JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker = if (request.avsenderMottaker?.erSamhandler() == true) { JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker( - navn = request.avsenderMottaker?.navn + navn = request.avsenderMottaker?.navn, ) } else { JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker( @@ -346,7 +335,7 @@ class OpprettJournalpostService( AvsenderMottakerDtoIdType.UTENLANDSK_ORGNR -> AvsenderMottakerIdType.UTL_ORG else -> AvsenderMottakerIdType.FNR } - } + }, ) } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/config/RestConfig.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/config/RestConfig.kt index 6f4f2d12..78e06df6 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/config/RestConfig.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/config/RestConfig.kt @@ -12,16 +12,16 @@ import java.time.format.DateTimeFormatter class RestConfig { @Bean - fun jackson2ObjectMapperBuilderCustomizer(): Jackson2ObjectMapperBuilderCustomizer = - Jackson2ObjectMapperBuilderCustomizer { - it.failOnUnknownProperties(false) - it.failOnEmptyBeans(false) - it.modulesToInstall( - JavaTimeModule() - .addDeserializer( - YearMonth::class.java, - YearMonthDeserializer(DateTimeFormatter.ofPattern("u-MM")) // Denne trengs for å parse år over 9999 riktig. - ) - ) - } + fun jackson2ObjectMapperBuilderCustomizer(): Jackson2ObjectMapperBuilderCustomizer = Jackson2ObjectMapperBuilderCustomizer { + it.failOnUnknownProperties(false) + it.failOnEmptyBeans(false) + it.modulesToInstall( + JavaTimeModule() + .addDeserializer( + YearMonth::class.java, + // Denne trengs for å parse år over 9999 riktig. + YearMonthDeserializer(DateTimeFormatter.ofPattern("u-MM")), + ), + ) + } } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Avvik.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Avvik.kt index 034c5fd3..adb4e181 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Avvik.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Avvik.kt @@ -28,11 +28,11 @@ data class AvvikshendelseIntern( var saksnummer: String? = null, var dokumenter: List? = emptyList(), var adresse: DistribuerTilAdresse? = null, - private val detaljer: Map = HashMap() + private val detaljer: Map = HashMap(), ) { val returDato: String get() = detaljer[AvvikDetaljer.RETUR_DATO] ?: throw AvvikDetaljException( - AvvikDetaljer.RETUR_DATO + AvvikDetaljer.RETUR_DATO, ) val enhetsnummer: String get() = detaljer[AvvikDetaljer.ENHETSNUMMER] @@ -42,7 +42,7 @@ data class AvvikshendelseIntern( ?: throw AvvikDetaljException(AvvikDetaljer.ENHETSNUMMER_GAMMELT) val enhetsnummerNytt: String get() = detaljer[AvvikDetaljer.ENHETSNUMMER_NYTT] ?: throw AvvikDetaljException( - AvvikDetaljer.ENHETSNUMMER_NYTT + AvvikDetaljer.ENHETSNUMMER_NYTT, ) val nyttFagomrade: String get() = detaljer[AvvikDetaljer.FAGOMRADE] @@ -52,14 +52,14 @@ data class AvvikshendelseIntern( ?: throw AvvikDetaljException(AvvikDetaljer.UTSENDINGSKANAL) val knyttTilSaker: List get() = detaljer[AvvikDetaljer.KNYTT_TIL_SAKER]?.split(",") ?: throw AvvikDetaljException( - AvvikDetaljer.KNYTT_TIL_SAKER + AvvikDetaljer.KNYTT_TIL_SAKER, ) val isBidragFagomrade: Boolean get() = nyttFagomrade == Fagomrade.BID.name || nyttFagomrade == Fagomrade.FAR.name constructor( avvikshendelse: Avvikshendelse, opprettetAvEnhetsnummer: String, - journalpostId: Long + journalpostId: Long, ) : this( avvikstype = AvvikType.valueOf(avvikshendelse.avvikType), beskrivelse = avvikshendelse.beskrivelse, @@ -68,45 +68,41 @@ data class AvvikshendelseIntern( dokumenter = avvikshendelse.dokumenter, saksnummer = avvikshendelse.saksnummer, detaljer = avvikshendelse.detaljer, - adresse = avvikshendelse.adresse + adresse = avvikshendelse.adresse, ) - fun toLeggTiLFarskapUtelukketTilTittelRequest(journalpost: Journalpost) = - EndreTittelRequest( - journalpostId, - "$FARSKAP_UTELUKKET_PREFIKS: ${journalpost.hentHoveddokument()?.tittel ?: journalpost.tittel}", - journalpost - ) + fun toLeggTiLFarskapUtelukketTilTittelRequest(journalpost: Journalpost) = EndreTittelRequest( + journalpostId, + "$FARSKAP_UTELUKKET_PREFIKS: ${journalpost.hentHoveddokument()?.tittel ?: journalpost.tittel}", + journalpost, + ) fun toEndreFagomradeRequest() = EndreFagomradeRequest(journalpostId, nyttFagomrade) - fun toEndreFagomradeOgKnyttTilSakRequest(bruker: Bruker) = - EndreFagomradeOgKnyttTilSakRequest( - journalpostId, - nyttFagomrade, - OppdaterJournalpostRequest.Bruker(bruker.id, bruker.type) - ) + fun toEndreFagomradeOgKnyttTilSakRequest(bruker: Bruker) = EndreFagomradeOgKnyttTilSakRequest( + journalpostId, + nyttFagomrade, + OppdaterJournalpostRequest.Bruker(bruker.id, bruker.type), + ) fun toEndreFagomradeJournalfortJournalpostRequest(journalpost: Journalpost) = EndreFagomradeJournalfortJournalpostRequest(journalpostId, journalpost) - fun toKnyttTilGenerellSakRequest(fagomrade: String, bruker: Bruker) = - EndreKnyttTilGenerellSakRequest( - journalpostId, - OppdaterJournalpostRequest.Bruker(bruker.id, bruker.type), - fagomrade - ) + fun toKnyttTilGenerellSakRequest(fagomrade: String, bruker: Bruker) = EndreKnyttTilGenerellSakRequest( + journalpostId, + OppdaterJournalpostRequest.Bruker(bruker.id, bruker.type), + fagomrade, + ) - fun toLeggTilBegrunnelsePaaTittelRequest(journalpost: Journalpost) = - EndreTittelRequest( - journalpostId, - "${journalpost.hentHoveddokument()?.tittel ?: journalpost.tittel} ($beskrivelse)", - journalpost - ) + fun toLeggTilBegrunnelsePaaTittelRequest(journalpost: Journalpost) = EndreTittelRequest( + journalpostId, + "${journalpost.hentHoveddokument()?.tittel ?: journalpost.tittel} ($beskrivelse)", + journalpost, + ) } data class OverforEnhetRequest( private var journalpostId: Long, - override var journalfoerendeEnhet: String? + override var journalfoerendeEnhet: String?, ) : OppdaterJournalpostRequest(journalpostId) @@ -117,12 +113,12 @@ data class EndreFagomradeOgKnyttTilSakRequest( private var journalpostId: Long, override var tema: String?, override var bruker: Bruker?, - override var sak: Sak? = GenerellSak() + override var sak: Sak? = GenerellSak(), ) : OppdaterJournalpostRequest(journalpostId) data class EndreFagomradeJournalfortJournalpostRequest( private var journalpostId: Long, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -141,7 +137,7 @@ data class OppdaterOriginalBestiltFlagg(private var journalpost: Journalpost) : data class OpphevEndreFagomradeJournalfortJournalpostRequest( private var journalpostId: Long, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -153,7 +149,7 @@ data class OpphevEndreFagomradeJournalfortJournalpostRequest( data class EndreTittelRequest( private var journalpostId: Long, private var _tittel: String?, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { @@ -171,18 +167,18 @@ data class EndreKnyttTilGenerellSakRequest( private var journalpostId: Long, override var bruker: Bruker?, override var tema: String?, - override var sak: Sak? = GenerellSak() + override var sak: Sak? = GenerellSak(), ) : OppdaterJournalpostRequest(journalpostId) data class InngaaendeTilUtgaaendeRequest( private var journalpostId: Long, - override var tema: String? + override var tema: String?, ) : OppdaterJournalpostRequest(journalpostId) data class RegistrerReturRequest( private var journalpostId: Long, private var _datoRetur: LocalDate, - private var _tilleggsopplysninger: TilleggsOpplysninger? + private var _tilleggsopplysninger: TilleggsOpplysninger?, ) : OppdaterJournalpostRequest(journalpostId) { init { datoRetur = DateUtils.formatDate(_datoRetur) diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Distribusjon.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Distribusjon.kt index 5269f0cc..02761b79 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Distribusjon.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Distribusjon.kt @@ -12,7 +12,7 @@ data class BestemDistribusjonKanalRequest( val mottakerId: String?, val gjelderId: String, val tema: String = "BID", - val forsendelseStoerrelse: Int? = null + val forsendelseStoerrelse: Int? = null, ) data class DokDistDistribuerJournalpostRequest( @@ -22,7 +22,7 @@ data class DokDistDistribuerJournalpostRequest( var dokumentProdApp: String = "bidragDokArkiv", var distribusjonstype: DistribusjonsType = DistribusjonsType.VIKTIG, var distribusjonstidspunkt: DistribusjonsTidspunkt = DistribusjonsTidspunkt.KJERNETID, - var adresse: DokDistDistribuerTilAdresse? = null + var adresse: DokDistDistribuerTilAdresse? = null, ) { private fun mapAdresse(distribuerTilAdresse: DistribuerTilAdresse?): DokDistDistribuerTilAdresse? { @@ -36,7 +36,7 @@ data class DokDistDistribuerJournalpostRequest( adressetype = dokDistAdresseType, land = adresse.land!!, postnummer = adresse.postnummer, - poststed = adresse.poststed + poststed = adresse.poststed, ) } @@ -45,9 +45,9 @@ data class DokDistDistribuerJournalpostRequest( brevkode: String?, tittel: String?, distribuerTilAdresse: DistribuerTilAdresse?, - _batchId: String? + _batchId: String?, ) : this( - journalpostId = journalpostId + journalpostId = journalpostId, ) { batchId = _batchId adresse = mapAdresse(distribuerTilAdresse) @@ -58,19 +58,19 @@ data class DokDistDistribuerJournalpostRequest( enum class DistribusjonsTidspunkt { UMIDDELBART, - KJERNETID + KJERNETID, } enum class DistribusjonsType { VEDTAK, VIKTIG, - ANNET + ANNET, } enum class DokDistAdresseType(val verdi: String) { // Kotlin code style krever at enumer begynner med stor bokstav. Lagt til verdi med gammelt ennum-navn for ikke å brekke noe. NorskPostadresse("norskPostadresse"), - UtenlandskPostadresse("utenlandskPostadresse") + UtenlandskPostadresse("utenlandskPostadresse"), } data class DokDistDistribuerTilAdresse( @@ -80,17 +80,17 @@ data class DokDistDistribuerTilAdresse( var adressetype: String, var land: String, var postnummer: String? = null, - var poststed: String? = null + var poststed: String? = null, ) data class DistribuerJournalpostRequestInternal( - var request: DistribuerJournalpostRequest? = null + var request: DistribuerJournalpostRequest? = null, ) { constructor(distribuerTilAdresse: DistribuerTilAdresse?) : this( DistribuerJournalpostRequest( - adresse = distribuerTilAdresse - ) + adresse = distribuerTilAdresse, + ), ) fun erLokalUtskrift(): Boolean = request?.lokalUtskrift ?: false @@ -104,7 +104,7 @@ data class DistribuerJournalpostRequestInternal( adresselinje3 = StringUtils.stripToNull(adresse.adresselinje3), land = adresse.land ?: ALPHA2_NORGE, poststed = StringUtils.stripToNull(adresse.poststed), - postnummer = StringUtils.stripToNull(adresse.postnummer) + postnummer = StringUtils.stripToNull(adresse.postnummer), ) } else { null @@ -113,7 +113,7 @@ data class DistribuerJournalpostRequestInternal( } data class DokDistDistribuerJournalpostResponse( - var bestillingsId: String + var bestillingsId: String, ) { fun toDistribuerJournalpostResponse(journalpostId: Long): DistribuerJournalpostResponse { return DistribuerJournalpostResponse("JOARK-$journalpostId", bestillingsId) @@ -124,27 +124,27 @@ fun validerKanDistribueres(journalpost: Journalpost?) { Validate.isTrue(journalpost != null, "Fant ingen journalpost") Validate.isTrue( journalpost != null && journalpost.hentTilknyttetSaker().size < 2, - "Kan bare distribuere journalpost med 1 sak" + "Kan bare distribuere journalpost med 1 sak", ) Validate.isTrue( journalpost?.journalstatus == JournalStatus.FERDIGSTILT, - "Journalpost må ha status FERDIGSTILT" + "Journalpost må ha status FERDIGSTILT", ) Validate.isTrue( journalpost?.tilleggsopplysninger?.isDistribusjonBestilt() == false, - "Journalpost er allerede distribuert" + "Journalpost er allerede distribuert", ) Validate.isTrue( journalpost?.hasMottakerId() == true || journalpost?.hentAvsenderNavn() ?.isNotEmpty() == true, - "Journalpost må ha satt mottakerId eller mottakerNavn" + "Journalpost må ha satt mottakerId eller mottakerNavn", ) } fun validerKanDistribueresUtenAdresse(journalpost: Journalpost?) { Validate.isTrue( journalpost?.hasMottakerId() == true, - "Journalpost må ha satt mottakerId for å kunne distribuere uten å sette adresse" + "Journalpost må ha satt mottakerId for å kunne distribuere uten å sette adresse", ) } @@ -153,22 +153,22 @@ fun validerAdresse(adresse: DistribuerTilAdresse?) { validateNotNullOrEmpty(adresse?.land, "Land er påkrevd på adresse") Validate.isTrue( adresse?.land?.length == 2, - "Land må være formatert som Alpha-2 to-bokstavers landkode " + "Land må være formatert som Alpha-2 to-bokstavers landkode ", ) validateMaxLength( adresse?.adresselinje1, 128, - "Adresselinje 1 kan ikke være lengre enn 128 tegn" + "Adresselinje 1 kan ikke være lengre enn 128 tegn", ) validateMaxLength( adresse?.adresselinje2, 128, - "Adresselinje 2 kan ikke være lengre enn 128 tegn" + "Adresselinje 2 kan ikke være lengre enn 128 tegn", ) validateMaxLength( adresse?.adresselinje3, 128, - "Adresselinje 3 kan ikke være lengre enn 128 tegn" + "Adresselinje 3 kan ikke være lengre enn 128 tegn", ) if (ALPHA2_NORGE == adresse?.land) { validateNotNullOrEmpty(adresse.postnummer, "Postnummer er påkrevd på norsk adresse") @@ -176,7 +176,7 @@ fun validerAdresse(adresse: DistribuerTilAdresse?) { } else { validateNotNullOrEmpty( adresse?.adresselinje1, - "Adresselinje1 er påkrevd på utenlandsk adresse" + "Adresselinje1 er påkrevd på utenlandsk adresse", ) } } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/DokumentoversiktFagsakQueryResponse.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/DokumentoversiktFagsakQueryResponse.kt index 3f12288a..87cc284d 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/DokumentoversiktFagsakQueryResponse.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/DokumentoversiktFagsakQueryResponse.kt @@ -3,7 +3,7 @@ package no.nav.bidrag.dokument.arkiv.dto import no.nav.bidrag.dokument.arkiv.model.JournalpostIkkeFunnetException data class DokumentoversiktFagsakQueryResponse( - var data: DokumentoversiktFagsak? = null + var data: DokumentoversiktFagsak? = null, ) { fun hentJournalpost(journalpostId: Long): Journalpost { return data?.dokumentoversiktFagsak?.journalposter?.find { it.journalpostId == journalpostId.toString() } @@ -12,9 +12,9 @@ data class DokumentoversiktFagsakQueryResponse( } data class DokumentoversiktFagsak( - var dokumentoversiktFagsak: DokumentoversiktFagsakListe? = null + var dokumentoversiktFagsak: DokumentoversiktFagsakListe? = null, ) data class DokumentoversiktFagsakListe( - var journalposter: List = emptyList() + var journalposter: List = emptyList(), ) diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Journalpost.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Journalpost.kt index df79d413..eae0756f 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Journalpost.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Journalpost.kt @@ -80,7 +80,7 @@ data class DistribusjonsInfo( val kanal: JournalpostKanal? = null, val utsendingsinfo: UtsendingsInfo? = null, val tilleggsopplysninger: TilleggsOpplysninger = TilleggsOpplysninger(), - val relevanteDatoer: List = emptyList() + val relevanteDatoer: List = emptyList(), ) { fun hentDatoDokument(): LocalDateTime? { val registrert = relevanteDatoer @@ -106,8 +106,7 @@ data class DistribusjonsInfo( fun isStatusEkspedert(): Boolean = journalstatus == JournalStatus.EKSPEDERT.name fun isUtgaaendeDokument(): Boolean = journalposttype == JournalpostType.U.name - fun isDistribusjonBestilt(): Boolean = - tilleggsopplysninger.isDistribusjonBestilt() || isStatusEkspedert() + fun isDistribusjonBestilt(): Boolean = tilleggsopplysninger.isDistribusjonBestilt() || isStatusEkspedert() fun hentJournalStatus(): JournalpostStatus { return when (journalstatus) { @@ -140,7 +139,7 @@ data class UtsendingsInfo( val epostVarselSendt: EpostVarselSendt? = null, val fysiskpostSendt: FysiskpostSendt? = null, val smsVarselSendt: SmsVarselSendt? = null, - val varselSendt: List = emptyList() + val varselSendt: List = emptyList(), ) { val sisteVarselSendt get() = if (varselSendt.isNotEmpty()) varselSendt[0] else null val varselType get() = if (varselSendt.isNotEmpty()) varselSendt[0] else null @@ -150,17 +149,17 @@ data class UtsendingsInfo( data class EpostVarselSendt( val adresse: String, val tittel: String, - val varslingstekst: String + val varslingstekst: String, ) @JsonIgnoreProperties(ignoreUnknown = true) data class DigitalpostSendt( - val adresse: String + val adresse: String, ) @JsonIgnoreProperties(ignoreUnknown = true) data class FysiskpostSendt( - val adressetekstKonvolutt: String + val adressetekstKonvolutt: String, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -169,13 +168,13 @@ data class VarselSendt( val varslingstekst: String, val adresse: String, val tittel: String?, - val type: String + val type: String, ) @JsonIgnoreProperties(ignoreUnknown = true) data class SmsVarselSendt( val varslingstekst: String, - val adresse: String + val adresse: String, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -199,7 +198,7 @@ data class Journalpost( var eksternReferanseId: String? = null, var tilknyttedeSaker: List = emptyList(), var tilleggsopplysninger: TilleggsOpplysninger = TilleggsOpplysninger(), - val utsendingsinfo: UtsendingsInfo? = null + val utsendingsinfo: UtsendingsInfo? = null, ) { fun distribuertTilAdresse(): DistribuerTilAdresse? { @@ -214,7 +213,7 @@ data class Journalpost( adresselinje3 = it.adresselinje3, postnummer = it.postnummer, poststed = it.poststed, - landkode = it.land + landkode = it.land, ) } } @@ -231,7 +230,7 @@ data class Journalpost( postnummerPoststed.getOrNull(0) } else { postnummerPoststed.getOrNull( - 1 + 1, ) } val adresselinje1 = when (postadresseSplit.size) { @@ -252,11 +251,11 @@ data class Journalpost( adresselinje3 = adresselinje3, poststed = poststed, postnummer = postnummer, - land = landkode2 + land = landkode2, ) SECURE_LOGGER.info { "Lest og mappet postadresse fra SAF ${ - it.split("\n").joinToString("\\n") + it.split("\n").joinToString("\\n") } til $adresse" } return adresse @@ -269,13 +268,11 @@ data class Journalpost( fun isBidragTema(): Boolean = tema == "BID" || tema == "FAR" fun isFarskap(): Boolean = tema == "FAR" - fun isFarskapUtelukket(): Boolean = - hentTittel()?.startsWith(FARSKAP_UTELUKKET_PREFIKS, ignoreCase = true) == true + fun isFarskapUtelukket(): Boolean = hentTittel()?.startsWith(FARSKAP_UTELUKKET_PREFIKS, ignoreCase = true) == true fun hentGjelderId(): String? = bruker?.id - fun harAvsenderMottaker(): Boolean = - avsenderMottaker?.navn != null || avsenderMottaker?.id != null + fun harAvsenderMottaker(): Boolean = avsenderMottaker?.navn != null || avsenderMottaker?.id != null fun hentAvsenderMottakerId(): String? = avsenderMottaker?.id fun hentJournalStatus(): JournalpostStatus? { @@ -310,13 +307,11 @@ data class Journalpost( } } - fun isDistribusjonKommetIRetur() = - (isDistribusjonBestilt()) && antallRetur != null && antallRetur!! > 0 + fun isDistribusjonKommetIRetur() = (isDistribusjonBestilt()) && antallRetur != null && antallRetur!! > 0 fun hentBrevkode(): String? = hentHoveddokument()?.brevkode - fun isDistribusjonBestilt(): Boolean = - tilleggsopplysninger.isDistribusjonBestilt() || isStatusEkspedert() || hasEkspedertDate() + fun isDistribusjonBestilt(): Boolean = tilleggsopplysninger.isDistribusjonBestilt() || isStatusEkspedert() || hasEkspedertDate() fun isFeilregistrert() = journalstatus == JournalStatus.FEILREGISTRERT @@ -340,8 +335,7 @@ data class Journalpost( fun isTemaEqualTo(likTema: String) = tema == likTema fun hentJournalpostIdLong() = journalpostId?.toLong() fun hentJournalpostIdMedPrefix() = "JOARK-$journalpostId" - fun hentJournalpostType() = - if (journalposttype == JournalpostType.N) "X" else journalposttype?.name + fun hentJournalpostType() = if (journalposttype == JournalpostType.N) "X" else journalposttype?.name fun hentDatoJournalfort(): LocalDate? { val journalfort = relevanteDatoer @@ -350,13 +344,11 @@ data class Journalpost( return journalfort?.somDato() } - fun hasReturDetaljerWithDate(date: LocalDate) = - !tilleggsopplysninger.hentReturDetaljerLogDO().stream().filter { it.dato == date } - .findAny().isEmpty + fun hasReturDetaljerWithDate(date: LocalDate) = !tilleggsopplysninger.hentReturDetaljerLogDO().stream().filter { it.dato == date } + .findAny().isEmpty - fun hasLockedReturDetaljerWithDate(date: LocalDate) = - !tilleggsopplysninger.hentReturDetaljerLogDO().stream() - .filter { it.dato == date && it.locked == true }.findAny().isEmpty + fun hasLockedReturDetaljerWithDate(date: LocalDate) = !tilleggsopplysninger.hentReturDetaljerLogDO().stream() + .filter { it.dato == date && it.locked == true }.findAny().isEmpty fun hentJournalfortAvNavn(): String? { return tilleggsopplysninger.hentJournalfortAv() ?: journalfortAvNavn @@ -373,7 +365,7 @@ data class Journalpost( .filter { it.dato != null && it.locked != true } .filter { !isDistribusjonKommetIRetur() || it.dato!!.isEqual(hentDatoDokument()) || it.dato!!.isAfter( - hentDatoDokument() + hentDatoDokument(), ) } .maxOfOrNull { it.dato!! } @@ -384,7 +376,7 @@ data class Journalpost( null }, logg = returDetaljerLog, - antall = returDetaljerLog.size + antall = returDetaljerLog.size, ) } @@ -406,7 +398,7 @@ data class Journalpost( ReturDetaljerLog( dato = it.dato, beskrivelse = it.beskrivelse, - locked = it.locked == true + locked = it.locked == true, ) }.toMutableList() @@ -448,8 +440,7 @@ data class Journalpost( tilknyttedeSaker = tilknyttedeSaker + listOf(tilknyttetSak) } - fun hentBrevkodeDto(): KodeDto? = - if (hentBrevkode() != null) KodeDto(kode = hentBrevkode()) else null + fun hentBrevkodeDto(): KodeDto? = if (hentBrevkode() != null) KodeDto(kode = hentBrevkode()) else null fun hentHoveddokument(): Dokument? = if (dokumenter.isNotEmpty()) dokumenter[0] else null fun hentTittel(): String? = hentHoveddokument()?.tittel ?: tittel @@ -471,7 +462,7 @@ data class Journalpost( else -> AvsenderMottakerDtoIdType.UKJENT } }, - adresse = mottakerAdresse() + adresse = mottakerAdresse(), ) } else { null @@ -497,7 +488,7 @@ data class Journalpost( mottattDato = hentDatoRegistrert(), returDetaljer = hentReturDetaljer(), brevkode = hentBrevkodeDto(), - distribuertTilAdresse = distribuertTilAdresse() + distribuertTilAdresse = distribuertTilAdresse(), ) } @@ -528,13 +519,13 @@ data class Journalpost( } if (isUtgaaendeDokument() && !isLokalUtksrift() && isDistribusjonKommetIRetur() && !tilleggsopplysninger.isNyDistribusjonBestilt()) { avvikTypeList.add( - AvvikType.BESTILL_NY_DISTRIBUSJON + AvvikType.BESTILL_NY_DISTRIBUSJON, ) } if (isUtgaaendeDokument() && kanal != JournalpostKanal.INGEN_DISTRIBUSJON) { if (isStatusEkspedert() && isDistribusjonKommetIRetur() || isStatusFerdigsstilt() && !isDistribusjonBestilt()) { avvikTypeList.add( - AvvikType.MANGLER_ADRESSE + AvvikType.MANGLER_ADRESSE, ) } } @@ -544,8 +535,7 @@ data class Journalpost( } fun hasMottakerId(): Boolean = avsenderMottaker?.id != null - fun isMottakerIdSamhandlerId(): Boolean = - avsenderMottaker?.id?.startsWith("8") ?: avsenderMottaker?.id?.startsWith("9") ?: false + fun isMottakerIdSamhandlerId(): Boolean = avsenderMottaker?.id?.startsWith("8") ?: avsenderMottaker?.id?.startsWith("9") ?: false fun hasSak(): Boolean = sak != null fun isStatusFeilregistrert(): Boolean = journalstatus == JournalStatus.FEILREGISTRERT @@ -590,8 +580,7 @@ data class Journalpost( private fun erTilknyttetSak(saksnummer: String?) = sak?.fagsakId == saksnummer fun hentAvsenderNavn() = avsenderMottaker?.navn - fun erIkkeTilknyttetSakNarOppgitt(saksnummer: String?) = - if (saksnummer == null) false else !erTilknyttetSak(saksnummer) + fun erIkkeTilknyttetSakNarOppgitt(saksnummer: String?) = if (saksnummer == null) false else !erTilknyttetSak(saksnummer) fun kanJournalfores(journalpost: Journalpost): Boolean { return journalpost.isStatusMottatt() && journalpost.hasSak() @@ -620,7 +609,7 @@ enum class JournalpostKanal(val beskrivelse: String) { SKAN_NETS("Skanning Nets"), SKAN_PEN("Skanning Pensjon"), - SKAN_IM("Skanning Iron Mountain") + SKAN_IM("Skanning Iron Mountain"), } fun JournalpostKanal.tilKanalDto() = when (this) { @@ -646,7 +635,7 @@ enum class JournalpostUtsendingKanal { EIA, EESSI, TRYGDERETTEN, - HELSENETTET + HELSENETTET, } @JsonIgnoreProperties(ignoreUnknown = true) @@ -657,16 +646,15 @@ data class DistribuertTilAdresseDo( var adresselinje3: String?, var land: String, var postnummer: String?, - var poststed: String? + var poststed: String?, ) { private fun asJsonString(): String = toJsonString(this) - fun toMap(): List> = - asJsonString().chunked(100).mapIndexed { index, it -> - mapOf( - "nokkel" to "$DISTRIBUERT_ADRESSE_KEY$index", - "verdi" to it - ) - } + fun toMap(): List> = asJsonString().chunked(100).mapIndexed { index, it -> + mapOf( + "nokkel" to "$DISTRIBUERT_ADRESSE_KEY$index", + "verdi" to it, + ) + } fun toDistribuerTilAdresse(): DistribuerTilAdresse { return DistribuerTilAdresse( @@ -675,7 +663,7 @@ data class DistribuertTilAdresseDo( adresselinje3 = adresselinje3, land = land, postnummer = postnummer, - poststed = poststed + poststed = poststed, ) } @@ -686,7 +674,7 @@ data class DistribuertTilAdresseDo( adresselinje3 = adresselinje3, landkode = land, postnummer = postnummer, - poststed = poststed + poststed = poststed, ) } } @@ -896,16 +884,16 @@ data class ReturDetaljerLogDO( var beskrivelse: String, @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd") var dato: LocalDate, - var locked: Boolean? = false + var locked: Boolean? = false, ) { fun toMap(): List> = beskrivelse.chunked(100).mapIndexed { index, it -> mapOf( "nokkel" to "${if (locked == true) "L" else ""}$RETUR_DETALJER_KEY${index}_${ - DateUtils.formatDate( - dato - ) + DateUtils.formatDate( + dato, + ) }", - "verdi" to it + "verdi" to it, ) } } @@ -913,7 +901,7 @@ data class ReturDetaljerLogDO( data class AvsenderMottaker( var navn: String? = null, var id: String? = null, - var type: AvsenderMottakerIdType? = null + var type: AvsenderMottakerIdType? = null, ) enum class AvsenderMottakerIdType { @@ -922,23 +910,23 @@ enum class AvsenderMottakerIdType { ORGNR, HPRNR, UTL_ORG, - NULL + NULL, } enum class BrukerType { AKTOERID, - FNR + FNR, } data class Bruker( var id: String? = null, - var type: String? = null + var type: String? = null, ) { fun tilAktorDto(): AktorDto { return if (id != null) { AktorDto( id!!, - runCatchingIgnoreException { type?.let { IdentType.valueOf(it) } } ?: IdentType.FNR + runCatchingIgnoreException { type?.let { IdentType.valueOf(it) } } ?: IdentType.FNR, ) } else { throw JournalpostDataException("ingen id i $this") @@ -954,7 +942,7 @@ data class Bruker( data class Dokument( var tittel: String? = null, var dokumentInfoId: String? = null, - var brevkode: String? = null + var brevkode: String? = null, ) { fun tilDokumentDto(journalposttype: String?): DokumentDto = DokumentDto( arkivSystem = DokumentArkivSystemDto.JOARK, @@ -962,13 +950,13 @@ data class Dokument( dokumentreferanse = this.dokumentInfoId, dokumentType = journalposttype, status = DokumentStatusDto.FERDIGSTILT, - tittel = this.tittel + tittel = this.tittel, ) } data class DatoType( var dato: String? = null, - var datotype: String? = null + var datotype: String? = null, ) { fun somDato(): LocalDate { val datoStreng = dato?.substring(0, 10) @@ -977,7 +965,7 @@ data class DatoType( LocalDate.parse(datoStreng) } else { throw JournalpostDataException( - "Kunne ikke trekke ut dato fra: $dato" + "Kunne ikke trekke ut dato fra: $dato", ) } } @@ -989,7 +977,7 @@ data class Sak( var fagsakId: String? = null, var fagsakSystem: String? = null, var sakstype: String? = null, - var tema: String? = null + var tema: String? = null, ) { constructor(fagsakId: String?) : this(fagsakId, null, null, null) } @@ -1006,23 +994,22 @@ enum class JournalStatus { UKJENT_BRUKER, RESERVERT, OPPLASTING_DOKUMENT, - UKJENT + UKJENT, } data class EndreJournalpostCommandIntern( val endreJournalpostCommand: EndreJournalpostCommand, val enhet: String?, - val endreAdresse: DistribuertTilAdresseDo? + val endreAdresse: DistribuertTilAdresseDo?, ) { constructor(endreJournalpostCommand: EndreJournalpostCommand, enhet: String) : this( endreJournalpostCommand, enhet, - null + null, ) fun skalJournalfores() = endreJournalpostCommand.skalJournalfores - fun hentAvsenderNavn(journalpost: Journalpost) = - endreJournalpostCommand.avsenderNavn ?: journalpost.hentAvsenderNavn() + fun hentAvsenderNavn(journalpost: Journalpost) = endreJournalpostCommand.avsenderNavn ?: journalpost.hentAvsenderNavn() fun harEnTilknyttetSak(): Boolean = endreJournalpostCommand.tilknyttSaker.isNotEmpty() fun harGjelder(): Boolean = endreJournalpostCommand.gjelder != null @@ -1030,8 +1017,7 @@ data class EndreJournalpostCommandIntern( fun hentTilknyttetSaker() = endreJournalpostCommand.tilknyttSaker fun hentFagomrade() = endreJournalpostCommand.fagomrade fun hentGjelder() = endreJournalpostCommand.gjelder - fun hentGjelderType() = - if (endreJournalpostCommand.gjelderType != null) endreJournalpostCommand.gjelderType!! else IdentType.FNR + fun hentGjelderType() = if (endreJournalpostCommand.gjelderType != null) endreJournalpostCommand.gjelderType!! else IdentType.FNR fun sjekkGyldigEndring(journalpost: Journalpost) { val violations = mutableListOf() @@ -1090,13 +1076,13 @@ data class EndreJournalpostCommandIntern( val endringAvLaastReturDetalj = endreReturDetaljer.any { it.originalDato != null && journalpost.hasLockedReturDetaljerWithDate( - it.originalDato!! + it.originalDato!!, ) } val opprettelseAvEksisterendeReturDato = endreReturDetaljer.any { it.originalDato == null && journalpost.hasLockedReturDetaljerWithDate( - it.nyDato!! + it.nyDato!!, ) } if (endringAvLaastReturDetalj || opprettelseAvEksisterendeReturDato) { @@ -1124,11 +1110,11 @@ data class TilknyttetJournalpost( var journalpostId: Long, var journalstatus: JournalStatus, var sak: Sak?, - var dokumenter: List = emptyList() + var dokumenter: List = emptyList(), ) { fun isNotFeilregistrert() = journalstatus != JournalStatus.FEILREGISTRERT data class TilknyttetDokument( - val tittel: String? = null + val tittel: String? = null, ) val tittel get() = dokumenter.firstOrNull()?.tittel @@ -1138,12 +1124,12 @@ fun returDetaljerDOListDoToMap(returDetaljerLog: List): Map< return mapOf( "nokkel" to RETUR_DETALJER_KEY, "verdi" to jacksonObjectMapper().registerModule(JavaTimeModule()) - .writeValueAsString(returDetaljerLog) + .writeValueAsString(returDetaljerLog), ) } enum class JournalpostType(var dekode: String) { N("Notat"), I("Inngående dokument"), - U("Utgående dokument") + U("Utgående dokument"), } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/KnyttTilAnnenSak.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/KnyttTilAnnenSak.kt index 18251827..e6ee552e 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/KnyttTilAnnenSak.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/KnyttTilAnnenSak.kt @@ -8,52 +8,52 @@ open class KnyttTilAnnenSakRequest( open var sakstype: String, open var journalfoerendeEnhet: String, open var bruker: KnyttTilBruker, - open var tema: String + open var tema: String, ) data class KnyttTilSakRequest( override var fagsakId: String?, override var journalfoerendeEnhet: String, override var bruker: KnyttTilBruker, - override var tema: String + override var tema: String, ) : KnyttTilAnnenSakRequest( sakstype = "FAGSAK", fagsaksystem = "BISYS", fagsakId = fagsakId, journalfoerendeEnhet = journalfoerendeEnhet, bruker = bruker, - tema = tema + tema = tema, ) { constructor(saksnummer: String, journalpost: Journalpost) : this(saksnummer, journalpost, null) constructor(saksnummer: String, journalpost: Journalpost, tema: String?) : this( fagsakId = saksnummer, journalfoerendeEnhet = journalpost.journalforendeEnhet ?: "", bruker = KnyttTilBruker(journalpost.bruker?.id, journalpost.bruker?.type), - tema = tema ?: journalpost.tema ?: throw KnyttTilSakManglerTemaException("Kunne ikke knytte journalpost til annen sak. Journalpost mangler tema. ") + tema = tema ?: journalpost.tema ?: throw KnyttTilSakManglerTemaException("Kunne ikke knytte journalpost til annen sak. Journalpost mangler tema. "), ) } data class KnyttTilGenerellSakRequest( override var journalfoerendeEnhet: String, override var bruker: KnyttTilBruker, - override var tema: String + override var tema: String, ) : KnyttTilAnnenSakRequest( sakstype = "GENERELL_SAK", journalfoerendeEnhet = journalfoerendeEnhet, bruker = bruker, - tema = tema + tema = tema, ) { constructor(journalpost: Journalpost, tema: String?) : this( journalfoerendeEnhet = journalpost.journalforendeEnhet ?: "9999", bruker = KnyttTilBruker(journalpost.bruker?.id, journalpost.bruker?.type), - tema = tema ?: journalpost.tema ?: throw KnyttTilSakManglerTemaException("Kunne ikke knytte journalpost til annen sak. Journalpost mangler tema. ") + tema = tema ?: journalpost.tema ?: throw KnyttTilSakManglerTemaException("Kunne ikke knytte journalpost til annen sak. Journalpost mangler tema. "), ) } data class KnyttTilAnnenSakResponse( - var nyJournalpostId: String + var nyJournalpostId: String, ) data class KnyttTilBruker( val id: String?, - val idType: String? + val idType: String?, ) diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OppdaterJournalpost.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OppdaterJournalpost.kt index 889d1546..6025857e 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OppdaterJournalpost.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OppdaterJournalpost.kt @@ -12,7 +12,7 @@ import java.time.LocalTime data class OppdaterFlaggNyDistribusjonBestiltRequest( private var journalpostId: Long, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -23,7 +23,7 @@ data class OppdaterFlaggNyDistribusjonBestiltRequest( data class OppdaterDistribusjonsInfoRequest( val settStatusEkspedert: Boolean, - val utsendingsKanal: JournalpostUtsendingKanal + val utsendingsKanal: JournalpostUtsendingKanal, ) data class OpprettNyReturLoggRequest(private var journalpost: Journalpost, private val kommentar: String? = null) : @@ -38,8 +38,8 @@ data class OpprettNyReturLoggRequest(private var journalpost: Journalpost, priva journalpost.tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( kommentar ?: "Returpost", - dateNow - ) + dateNow, + ), ) } tilleggsopplysninger = journalpost.tilleggsopplysninger @@ -52,8 +52,8 @@ data class LagreReturDetaljForSisteReturRequest(private var journalpost: Journal journalpost.tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "Returpost", - journalpost.hentDatoRetur()!! - ) + journalpost.hentDatoRetur()!!, + ), ) tilleggsopplysninger = journalpost.tilleggsopplysninger } @@ -61,7 +61,7 @@ data class LagreReturDetaljForSisteReturRequest(private var journalpost: Journal data class LagreAvsenderNavnRequest( private var journalpostId: Long, - private var avsenderNavn: String + private var avsenderNavn: String, ) : OppdaterJournalpostRequest(journalpostId = journalpostId) { init { @@ -82,7 +82,7 @@ data class LockReturDetaljerRequest(private var journalpost: Journalpost) : data class LeggTilBeskjedPåTittel( private var journalpostId: Long, private var journalpost: Journalpost, - private val beskjed: String + private val beskjed: String, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -91,15 +91,15 @@ data class LeggTilBeskjedPåTittel( listOf( Dokument( dokumentInfoId = hoveddokument.dokumentInfoId, - tittel = "${hoveddokument.tittel} ($beskjed)" - ) + tittel = "${hoveddokument.tittel} ($beskjed)", + ), ) } } data class OppdaterDokumentdatoTilIdag( private var journalpostId: Long, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -109,7 +109,7 @@ data class OppdaterDokumentdatoTilIdag( data class OppdaterJournalpostTilleggsopplysninger( private var journalpostId: Long, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -119,7 +119,7 @@ data class OppdaterJournalpostTilleggsopplysninger( data class OppdaterJournalpostDistribusjonsInfoRequest( private var journalpostId: Long, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { @@ -131,7 +131,7 @@ data class OppdaterJournalpostDistribusjonsInfoRequest( data class LagreAdresseRequest( private var journalpostId: Long, private val mottakerAdresse: DistribuerTilAdresse?, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { val mottakerAdresseDO = mapToAdresseDO(mottakerAdresse) @@ -149,7 +149,7 @@ data class LagreAdresseRequest( adresselinje3 = adresse.adresselinje3, land = adresse.land!!, poststed = adresse.poststed, - postnummer = adresse.postnummer + postnummer = adresse.postnummer, ) } else { null @@ -160,7 +160,7 @@ data class LagreAdresseRequest( data class LagreJournalfortAvIdentRequest( private var journalpostId: Long, private var journalpost: Journalpost, - private var journalfortAvIdent: String + private var journalfortAvIdent: String, ) : OppdaterJournalpostRequest(journalpostId) { init { journalpost.tilleggsopplysninger.setJournalfortAvIdent(journalfortAvIdent) @@ -171,7 +171,7 @@ data class LagreJournalfortAvIdentRequest( data class LagreJournalpostRequest( private var journalpostId: Long, private var endreJournalpostCommand: EndreJournalpostCommandIntern, - private var journalpost: Journalpost + private var journalpost: Journalpost, ) : OppdaterJournalpostRequest(journalpostId) { init { if (journalpost.isStatusMottatt()) { @@ -182,7 +182,7 @@ data class LagreJournalpostRequest( datoDokument = endreJournalpostCommand.endreJournalpostCommand.dokumentDato?.let { LocalDateTime.of( it, - LocalTime.MIDNIGHT + LocalTime.MIDNIGHT, ) }?.toString() } @@ -193,7 +193,7 @@ data class LagreJournalpostRequest( Dokument( dokument.dokId.toString(), dokument.tittel, - dokument.brevkode + dokument.brevkode, ) } } @@ -218,14 +218,14 @@ data class LagreJournalpostRequest( if (it.originalDato != null) { journalpost.tilleggsopplysninger.updateReturDetaljLog( it.originalDato!!, - ReturDetaljerLogDO(it.beskrivelse, it.nyDato ?: it.originalDato!!) + ReturDetaljerLogDO(it.beskrivelse, it.nyDato ?: it.originalDato!!), ) } else if (journalpost.manglerReturDetaljForSisteRetur() && it.nyDato != null && !journalpost.hasReturDetaljerWithDate( - it.nyDato!! + it.nyDato!!, ) ) { journalpost.tilleggsopplysninger.addReturDetaljLog( - ReturDetaljerLogDO(it.beskrivelse, it.nyDato!!) + ReturDetaljerLogDO(it.beskrivelse, it.nyDato!!), ) } } @@ -248,7 +248,7 @@ data class LagreJournalpostRequest( bruker = if (endreJournalpostCommand.hentGjelder() != null) { Bruker( endreJournalpostCommand.hentGjelder(), - endreJournalpostCommand.hentGjelderType().name + endreJournalpostCommand.hentGjelderType().name, ) } else if (journalpost.bruker != null) { Bruker(journalpost.bruker?.id, journalpost.bruker?.type) @@ -282,7 +282,7 @@ sealed class OppdaterJournalpostRequest(private var journalpostId: Long? = -1) { data class AvsenderMottaker( val navn: String? = null, var id: String? = null, - var idType: AvsenderMottakerIdType? = null + var idType: AvsenderMottakerIdType? = null, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -290,7 +290,7 @@ sealed class OppdaterJournalpostRequest(private var journalpostId: Long? = -1) { data class Dokument( val dokumentInfoId: String? = null, var tittel: String? = null, - val brevkode: String? = null + val brevkode: String? = null, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -316,29 +316,46 @@ data class FerdigstillJournalpostRequest( val journalfoerendeEnhet: String, val journalfortAvNavn: String? = null, val opprettetAvNavn: String? = null, - val datoJournal: LocalDate? = null + val datoJournal: LocalDate? = null, ) { constructor(journalpostId: Long, journalfoerendeEnhet: String) : this( journalpostId, journalfoerendeEnhet, null, null, - null + null, ) } enum class Sakstype { - FAGSAK, GENERELL_SAK + FAGSAK, + GENERELL_SAK, } enum class BrukerIdType { - FNR, ORGNR, AKTOERID + FNR, + ORGNR, + AKTOERID, } enum class Fagsaksystem { - FS38, FS36, UFM, OEBS, OB36, AO01, AO11, IT01, PP01, K9, BISYS, BA, EF, KONT + FS38, + FS36, + UFM, + OEBS, + OB36, + AO01, + AO11, + IT01, + PP01, + K9, + BISYS, + BA, + EF, + KONT, } enum class Fagomrade { - BID, FAR + BID, + FAR, } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Oppgave.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Oppgave.kt index 45f2ec03..b6a44800 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Oppgave.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Oppgave.kt @@ -17,14 +17,14 @@ private val NORSK_TIDSSTEMPEL_FORMAT = DateTimeFormatter.ofPattern("dd.MM.yyyy H data class OppgaveResponse(var id: Long?) data class OppgaveSokResponse( var antallTreffTotalt: Int = 0, - var oppgaver: List = ArrayList() + var oppgaver: List = ArrayList(), ) data class OpprettOppgaveResponse( var id: Long? = null, var tildeltEnhetsnr: String? = null, var tema: String? = null, - var oppgavetype: String? = null + var oppgavetype: String? = null, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -60,7 +60,7 @@ data class OppgaveData( val endretTidspunkt: String? = null, val prioritet: String? = null, val status: OppgaveStatus? = null, - val metadata: Map? = null + val metadata: Map? = null, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -75,24 +75,24 @@ open class OppgaveRequest( val tema: String? = null, val behandlingstema: String? = null, val oppgavetype: String? = null, - val status: OppgaveStatus? = null + val status: OppgaveStatus? = null, ) data class OppdaterSakRequest( private var oppgaveHendelse: OppgaveData, override var saksreferanse: String?, - private val kommentar: String? = null + private val kommentar: String? = null, ) : OppgaveRequest( id = oppgaveHendelse.id, versjon = oppgaveHendelse.versjon, - beskrivelse = if (kommentar != null) "${oppgaveHendelse.beskrivelse}\r\n\r\n$kommentar" else null + beskrivelse = if (kommentar != null) "${oppgaveHendelse.beskrivelse}\r\n\r\n$kommentar" else null, ) data class LeggTilKommentarPaaOppgave( private var oppgaveData: OppgaveData, private var _endretAvEnhetsnr: String, private val saksbehandlersInfo: String, - private val kommentar: String + private val kommentar: String, ) : OppgaveRequest( id = oppgaveData.id, @@ -100,18 +100,18 @@ data class LeggTilKommentarPaaOppgave( endretAvEnhetsnr = _endretAvEnhetsnr, beskrivelse = beskrivelseHeader(saksbehandlersInfo) + "$kommentar\r\n\r\n" + - "${oppgaveData.beskrivelse}" + "${oppgaveData.beskrivelse}", ) data class FerdigstillOppgaveRequest( private var oppgaveData: OppgaveData, - private var _endretAvEnhetsnr: String + private var _endretAvEnhetsnr: String, ) : OppgaveRequest( id = oppgaveData.id, versjon = oppgaveData.versjon, status = OppgaveStatus.FERDIGSTILT, - endretAvEnhetsnr = _endretAvEnhetsnr + endretAvEnhetsnr = _endretAvEnhetsnr, ) @Suppress("unused") // used by jackson... @@ -126,7 +126,7 @@ sealed class OpprettOppgaveRequest( open val saksreferanse: String? = null, var beskrivelse: String? = null, var tilordnetRessurs: String? = null, - open var fristFerdigstillelse: String? = null + open var fristFerdigstillelse: String? = null, ) { fun somHttpEntity(): HttpEntity<*> { @@ -143,7 +143,7 @@ sealed class OpprettOppgaveRequest( data class BestillSplittingoppgaveRequest( private val journalpost: Journalpost, private var saksbehandlerMedEnhet: SaksbehandlerMedEnhet, - private var beskrivSplitting: String? + private var beskrivSplitting: String?, ) : OpprettOppgaveFagpostRequest( @@ -151,11 +151,11 @@ data class BestillSplittingoppgaveRequest( oppgavetype = OppgaveType.BEST_RESCAN, opprettetAvEnhetsnr = saksbehandlerMedEnhet.enhetsnummer, saksreferanse = journalpost.hentSaksnummer(), - gjelderId = journalpost.hentGjelderId() + gjelderId = journalpost.hentGjelderId(), ) { init { beskrivelse = "${beskrivelseHeader(saksbehandlerMedEnhet.hentSaksbehandlerInfo())}\n${ - bestillSplittingKommentar(beskrivSplitting) + bestillSplittingKommentar(beskrivSplitting) }" } } @@ -165,7 +165,7 @@ data class BestillReskanningOppgaveRequest( private val journalpost: Journalpost, private var saksbehandlerMedEnhet: SaksbehandlerMedEnhet, private var kommentar: String?, - override var fristFerdigstillelse: String? = LocalDate.now().plusDays(5).toString() + override var fristFerdigstillelse: String? = LocalDate.now().plusDays(5).toString(), ) : OpprettOppgaveFagpostRequest( @@ -173,11 +173,11 @@ data class BestillReskanningOppgaveRequest( oppgavetype = OppgaveType.BEST_RESCAN, opprettetAvEnhetsnr = saksbehandlerMedEnhet.enhetsnummer, saksreferanse = journalpost.hentSaksnummer(), - gjelderId = journalpost.hentGjelderId() + gjelderId = journalpost.hentGjelderId(), ) { init { beskrivelse = "${beskrivelseHeader(saksbehandlerMedEnhet.hentSaksbehandlerInfo())}\n${ - bestillReskanningKommentar(kommentar) + bestillReskanningKommentar(kommentar) }" } } @@ -187,7 +187,7 @@ data class BestillOriginalOppgaveRequest( private val journalpost: Journalpost, private val enhet: String, private var saksbehandlerMedEnhet: SaksbehandlerMedEnhet, - private var kommentar: String? + private var kommentar: String?, ) : OpprettOppgaveFagpostRequest( @@ -195,7 +195,7 @@ data class BestillOriginalOppgaveRequest( oppgavetype = OppgaveType.BEST_ORGINAL, opprettetAvEnhetsnr = saksbehandlerMedEnhet.enhetsnummer, saksreferanse = journalpost.hentSaksnummer(), - gjelderId = journalpost.hentGjelderId() + gjelderId = journalpost.hentGjelderId(), ) { init { beskrivelse = """ @@ -214,7 +214,7 @@ sealed class OpprettOppgaveFagpostRequest( override var saksreferanse: String?, override var opprettetAvEnhetsnr: String, var aktoerId: String? = null, - private val gjelderId: String? + private val gjelderId: String?, ) : OpprettOppgaveRequest( @@ -223,7 +223,7 @@ sealed class OpprettOppgaveFagpostRequest( prioritet = Prioritet.NORM.name, fristFerdigstillelse = LocalDate.now().plusDays(5).toString(), tildeltEnhetsnr = OppgaveEnhet.FAGPOST, - tema = "GEN" + tema = "GEN", ) { fun hentGjelderId() = gjelderId @@ -238,7 +238,7 @@ data class OpprettVurderDokumentOppgaveRequest( override var tema: String, var aktoerId: String, private var saksbehandlerMedEnhet: SaksbehandlerMedEnhet, - private var kommentar: String? + private var kommentar: String?, ) : OpprettOppgaveRequest( journalpostId = journalpostId, @@ -251,8 +251,8 @@ data class OpprettVurderDokumentOppgaveRequest( journalpost.dokumenter[0].brevkode, journalpost.tittel!!, kommentar, - journalpost.hentDatoRegistrert() ?: LocalDate.now() - ) + journalpost.hentDatoRegistrert() ?: LocalDate.now(), + ), ) @Suppress("unused") // påkrevd felt som brukes av jackson men som ikke brukes aktivt @@ -260,35 +260,27 @@ data class OpprettBehandleDokumentOppgaveRequest( private var journalpost: Journalpost, var aktoerId: String, private val saksnummer: String, - private var saksbehandlerMedEnhet: SaksbehandlerMedEnhet + private var saksbehandlerMedEnhet: SaksbehandlerMedEnhet, ) : OpprettOppgaveRequest( journalpostId = journalpost.journalpostId!!, beskrivelse = lagDokumentOppgaveTittel( "Behandle dokument", journalpost.tittel!!, - journalpost.hentDatoRegistrert() ?: LocalDate.now() + journalpost.hentDatoRegistrert() ?: LocalDate.now(), ), fristFerdigstillelse = LocalDate.now().plusDays(1).toString(), opprettetAvEnhetsnr = saksbehandlerMedEnhet.enhetsnummer!!, oppgavetype = OppgaveType.BEH_SAK, saksreferanse = saksnummer, tildeltEnhetsnr = saksbehandlerMedEnhet.enhetsnummer, - tilordnetRessurs = saksbehandlerMedEnhet.saksbehandler.ident + tilordnetRessurs = saksbehandlerMedEnhet.saksbehandler.ident, ) -internal fun lagDokumentOppgaveTittelForEndring( - oppgaveNavn: String, - dokumentbeskrivelse: String, - dokumentdato: LocalDate -) = +internal fun lagDokumentOppgaveTittelForEndring(oppgaveNavn: String, dokumentbeskrivelse: String, dokumentdato: LocalDate) = "\u00B7 ${lagDokumentOppgaveTittel(oppgaveNavn, dokumentbeskrivelse, dokumentdato)}" -internal fun lagDokumentOppgaveTittel( - oppgaveNavn: String, - dokumentbeskrivelse: String, - dokumentdato: LocalDate -) = +internal fun lagDokumentOppgaveTittel(oppgaveNavn: String, dokumentbeskrivelse: String, dokumentdato: LocalDate) = "$oppgaveNavn ($dokumentbeskrivelse) mottatt ${dokumentdato.format(NORSK_DATO_FORMAT)}" internal fun lagVurderDokumentOppgaveBeskrivelse( @@ -296,10 +288,10 @@ internal fun lagVurderDokumentOppgaveBeskrivelse( brevKode: String?, dokumentTittel: String?, kommentar: String?, - regDato: LocalDate + regDato: LocalDate, ): String { var description = "--- ${ - LocalDate.now().format(NORSK_DATO_FORMAT) + LocalDate.now().format(NORSK_DATO_FORMAT) } ${saksbehandlerMedEnhet.hentSaksbehandlerInfo()} ---\n $brevKode $dokumentTittel" if (kommentar != null) { description += "\n\n $kommentar" @@ -316,7 +308,7 @@ enum class OppgaveType { VUR, JFR, BEST_RESCAN, - BEST_ORGINAL + BEST_ORGINAL, } object OppgaveEnhet { @@ -324,11 +316,12 @@ object OppgaveEnhet { } enum class Prioritet { - HOY, NORM, LAV + HOY, + NORM, + LAV, } -fun beskrivelseHeader(saksbehandlerInfo: String) = - "--- ${LocalDateTime.now().format(NORSK_TIDSSTEMPEL_FORMAT)} $saksbehandlerInfo ---\r\n" +fun beskrivelseHeader(saksbehandlerInfo: String) = "--- ${LocalDateTime.now().format(NORSK_TIDSSTEMPEL_FORMAT)} $saksbehandlerInfo ---\r\n" fun bestillReskanningKommentar(beskrivReskanning: String?) = """ Bestill reskanning: diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpost.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpost.kt index 825121b6..ff3d28b6 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpost.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpost.kt @@ -26,7 +26,7 @@ data class JoarkOpprettJournalpostRequest( val datoMottatt: String? = null, val bruker: OpprettJournalpostBruker? = null, val dokumenter: List = listOf(), - val avsenderMottaker: OpprettJournalpostAvsenderMottaker? = null + val avsenderMottaker: OpprettJournalpostAvsenderMottaker? = null, ) { @Suppress("unused") // properties used by jackson @JsonIgnoreProperties(ignoreUnknown = true) @@ -41,7 +41,7 @@ data class JoarkOpprettJournalpostRequest( data class OpprettJournalpostAvsenderMottaker( val navn: String? = null, val id: String? = null, - val idType: AvsenderMottakerIdType? = null + val idType: AvsenderMottakerIdType? = null, ) @JsonIgnoreProperties(ignoreUnknown = true) @@ -55,7 +55,7 @@ data class JoarkOpprettJournalpostRequest( val dokumentInfoId: String? = null, val tittel: String? = null, val brevkode: String? = null, - val dokumentvarianter: List = emptyList() + val dokumentvarianter: List = emptyList(), ) @Suppress("unused") // properties used by jackson @@ -65,7 +65,7 @@ data class JoarkOpprettJournalpostRequest( val filtype: String? = null, val variantformat: String? = null, val fysiskDokument: ByteArray, - val filnavn: String? = null + val filnavn: String? = null, ) } @@ -118,7 +118,7 @@ class OpprettJournalpostRequestBuilder { JoarkOpprettJournalpostRequest.Dokument( tittel = it.tittel, brevkode = it.brevkode, - dokumentInfoId = it.dokumentInfoId + dokumentInfoId = it.dokumentInfoId, ) }.toMutableList() } @@ -146,7 +146,7 @@ class OpprettJournalpostRequestBuilder { null } else { JoarkOpprettJournalpostRequest.OpprettJournalpostSak( - journalpost.sak?.fagsakId + journalpost.sak?.fagsakId, ) }, tema = tema ?: "BID", @@ -180,11 +180,11 @@ class OpprettJournalpostRequestBuilder { avsenderMottaker = JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker( journalpost.avsenderMottaker?.navn, journalpost.avsenderMottaker?.id, - avsenderType + avsenderType, ), bruker = JoarkOpprettJournalpostRequest.OpprettJournalpostBruker( journalpost.bruker?.id, - journalpost.bruker?.type + journalpost.bruker?.type, ), tilleggsopplysninger = if (fjernDistribusjonMetadata) { val tillegssopplysninger = TilleggsOpplysninger() @@ -203,30 +203,24 @@ class OpprettJournalpostRequestBuilder { ?.toString() } else { null - } + }, ) } } @OpprettJournalpostRequestBuilderDsl -fun dupliserJournalpost( - journalpost: Journalpost, - setup: OpprettJournalpostRequestBuilder.() -> Unit -): JoarkOpprettJournalpostRequest { +fun dupliserJournalpost(journalpost: Journalpost, setup: OpprettJournalpostRequestBuilder.() -> Unit): JoarkOpprettJournalpostRequest { val opprettJournalpostBuilder = OpprettJournalpostRequestBuilder() opprettJournalpostBuilder.setup() return opprettJournalpostBuilder.build(journalpost) } -fun opprettDokumentVariant( - filnavn: String? = null, - dokumentByte: ByteArray -): JoarkOpprettJournalpostRequest.DokumentVariant { +fun opprettDokumentVariant(filnavn: String? = null, dokumentByte: ByteArray): JoarkOpprettJournalpostRequest.DokumentVariant { return JoarkOpprettJournalpostRequest.DokumentVariant( variantformat = "ARKIV", filtype = "PDFA", fysiskDokument = dokumentByte, - filnavn = if (filnavn != null) "$filnavn.pdf" else null + filnavn = if (filnavn != null) "$filnavn.pdf" else null, ) } @@ -235,24 +229,24 @@ data class JoarkOpprettJournalpostResponse( val journalstatus: String? = null, val melding: String? = null, val journalpostferdigstilt: Boolean = false, - val dokumenter: List? = emptyList() + val dokumenter: List? = emptyList(), ) data class OpprettDokument( var dokumentInfoId: String?, var dokument: ByteArray?, var tittel: String?, - var brevkode: String? + var brevkode: String?, ) data class DokumentInfo( - val dokumentInfoId: String? + val dokumentInfoId: String?, ) enum class JoarkJournalpostType { INNGAAENDE, UTGAAENDE, - NOTAT + NOTAT, } enum class JoarkMottakUtsendingKanal { @@ -261,19 +255,16 @@ enum class JoarkMottakUtsendingKanal { SKAN_BID, S, // Sentral print L, // Lokal print - INGEN_DISTRIBUSJON + INGEN_DISTRIBUSJON, } -fun validerKanOppretteJournalpost( - opprettJournalpost: JoarkOpprettJournalpostRequest, - skalFerdigstilles: Boolean = false -) { +fun validerKanOppretteJournalpost(opprettJournalpost: JoarkOpprettJournalpostRequest, skalFerdigstilles: Boolean = false) { Validate.isTrue(opprettJournalpost.journalpostType != null, "Journalposttype må settes") Validate.isTrue(opprettJournalpost.bruker?.id != null, "Journalpost må ha satt brukerid") opprettJournalpost.dokumenter.forEach { Validate.isTrue( it.dokumentvarianter.isNotEmpty(), - "Dokument \"${it.dokumentInfoId ?: it.tittel}\" må minst ha en dokumentvariant" + "Dokument \"${it.dokumentInfoId ?: it.tittel}\" må minst ha en dokumentvariant", ) Validate.isTrue(!it.tittel.isNullOrEmpty(), "Alle dokumenter må ha tittel") } @@ -281,7 +272,7 @@ fun validerKanOppretteJournalpost( if (opprettJournalpost.journalpostType != JoarkJournalpostType.NOTAT) { Validate.isTrue( opprettJournalpost.hasAvsenderMottaker(), - "Journalpost må ha satt avsender/mottaker" + "Journalpost må ha satt avsender/mottaker", ) } @@ -292,22 +283,22 @@ fun validerKanOppretteJournalpost( if (opprettJournalpost.journalpostType == JoarkJournalpostType.INNGAAENDE) { Validate.isTrue( opprettJournalpost.kanal != null, - "Kanal må settes for inngående journalpost" + "Kanal må settes for inngående journalpost", ) } if (skalFerdigstilles) { Validate.isTrue( opprettJournalpost.tema == "BID" || opprettJournalpost.tema == "FAR", - "Journalpost som skal ferdigstilles må ha tema BID/FAR" + "Journalpost som skal ferdigstilles må ha tema BID/FAR", ) Validate.isTrue( !opprettJournalpost.journalfoerendeEnhet.isNullOrEmpty(), - "Journalpost som skal ferdigstilles må ha satt journalførendeEnhet" + "Journalpost som skal ferdigstilles må ha satt journalførendeEnhet", ) Validate.isTrue( opprettJournalpost.hasSak(), - "Journalpost som skal ferdigstilles må ha minst en sak" + "Journalpost som skal ferdigstilles må ha minst en sak", ) } } @@ -315,7 +306,7 @@ fun validerKanOppretteJournalpost( fun validerUtgaaendeJournalpostKanDupliseres(journalpost: Journalpost) { Validate.isTrue( journalpost.tema == "BID" || journalpost.tema == "FAR", - "Journalpost må ha tema BID/FAR" + "Journalpost må ha tema BID/FAR", ) Validate.isTrue(journalpost.isUtgaaendeDokument(), "Journalpost må være utgående dokument") Validate.isTrue(journalpost.hasMottakerId(), "Journalpost må ha satt mottakerId") @@ -328,29 +319,29 @@ fun validerKanOppretteJournalpost(request: OpprettJournalpostRequest) { request.dokumenter.forEachIndexed { index, it -> Validate.isTrue( it.tittel.isNotEmpty(), - "Dokument ${index + 1} mangler tittel. Alle dokumenter må ha satt tittel" + "Dokument ${index + 1} mangler tittel. Alle dokumenter må ha satt tittel", ) } if (request.journalposttype != no.nav.bidrag.transport.dokument.JournalpostType.NOTAT) { Validate.isTrue( request.hasAvsenderMottaker(), - "Journalpost må ha satt avsender/mottaker navn eller ident" + "Journalpost må ha satt avsender/mottaker navn eller ident", ) validateMaxLength( request.avsenderMottaker?.navn, 128, - "Navn på mottaker kan ikke være lengre enn 128 tegn" + "Navn på mottaker kan ikke være lengre enn 128 tegn", ) } if (request.skalFerdigstilles) { Validate.isTrue( request.tema == "BID" || request.tema == "FAR", - "Journalpost som skal ferdigstilles må ha tema BID/FAR" + "Journalpost som skal ferdigstilles må ha tema BID/FAR", ) Validate.isTrue( !request.hentJournalførendeEnhet().isNullOrEmpty(), - "Journalpost som skal ferdigstilles må ha satt journalførendeEnhet" + "Journalpost som skal ferdigstilles må ha satt journalførendeEnhet", ) Validate.isTrue(request.hasSak(), "Journalpost som skal ferdigstilles må ha minst en sak") } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostRequestExtension.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostRequestExtension.kt index 7f71f8c1..671b4cbe 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostRequestExtension.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostRequestExtension.kt @@ -4,21 +4,17 @@ import no.nav.bidrag.transport.dokument.AvsenderMottakerDto import no.nav.bidrag.transport.dokument.AvsenderMottakerDtoIdType import no.nav.bidrag.transport.dokument.OpprettJournalpostRequest -fun OpprettJournalpostRequest.hasAvsenderMottaker(): Boolean = - !avsenderMottaker?.navn.isNullOrEmpty() || !avsenderMottaker?.ident.isNullOrEmpty() +fun OpprettJournalpostRequest.hasAvsenderMottaker(): Boolean = !avsenderMottaker?.navn.isNullOrEmpty() || !avsenderMottaker?.ident.isNullOrEmpty() fun OpprettJournalpostRequest.hasSak(): Boolean = skalFerdigstilles && tilknyttSaker.isNotEmpty() -fun OpprettJournalpostRequest.hasGjelder(): Boolean = - !gjelder?.ident.isNullOrEmpty() || !gjelderIdent.isNullOrEmpty() +fun OpprettJournalpostRequest.hasGjelder(): Boolean = !gjelder?.ident.isNullOrEmpty() || !gjelderIdent.isNullOrEmpty() -fun OpprettJournalpostRequest.hentJournalførendeEnhet(): String? = - journalførendeEnhet ?: journalfoerendeEnhet +fun OpprettJournalpostRequest.hentJournalførendeEnhet(): String? = journalførendeEnhet ?: journalfoerendeEnhet fun OpprettJournalpostRequest.hentGjelderIdent() = gjelderIdent ?: gjelder?.ident fun AvsenderMottakerDto.erSamhandler(): Boolean = type == AvsenderMottakerDtoIdType.SAMHANDLER -fun JoarkOpprettJournalpostRequest.hasAvsenderMottaker(): Boolean = - !avsenderMottaker?.navn.isNullOrEmpty() || !avsenderMottaker?.id.isNullOrEmpty() +fun JoarkOpprettJournalpostRequest.hasAvsenderMottaker(): Boolean = !avsenderMottaker?.navn.isNullOrEmpty() || !avsenderMottaker?.id.isNullOrEmpty() fun JoarkOpprettJournalpostRequest.hasSak(): Boolean = !sak?.fagsakId.isNullOrEmpty() fun OpprettJournalpostRequest.hentGjelderType(): BrukerIdType? = when (hentGjelderIdent()?.length) { diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Saksbehandler.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Saksbehandler.kt index 1897ac50..7eb27ba4 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Saksbehandler.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/Saksbehandler.kt @@ -2,10 +2,11 @@ package no.nav.bidrag.dokument.arkiv.dto data class Saksbehandler( var ident: String? = null, - var navn: String? = null + var navn: String? = null, ) { fun hentIdentMedNavn() = "$ident - $navn" - fun hentSaksbehandlerInfo(saksbehandlerEnhet: String) = if (ident == null && navn == null) "ukjent saksbehandler" else hentBrukeridentMedSaksbehandler(saksbehandlerEnhet) + fun hentSaksbehandlerInfo(saksbehandlerEnhet: String) = + if (ident == null && navn == null) "ukjent saksbehandler" else hentBrukeridentMedSaksbehandler(saksbehandlerEnhet) private fun hentBrukeridentMedSaksbehandler(enhetsnummer: String) = "${navn ?: "Ukjent"} (${ident ?: "Ukjent"} - $enhetsnummer)" fun tilEnhet(enhetsnummer: String?): SaksbehandlerMedEnhet { return SaksbehandlerMedEnhet(this, enhetsnummer ?: "9999") diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/security/TokenForBasicAuthentication.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/security/TokenForBasicAuthentication.kt index ac6c4344..7cde8454 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/security/TokenForBasicAuthentication.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/dto/security/TokenForBasicAuthentication.kt @@ -6,7 +6,7 @@ import com.fasterxml.jackson.annotation.JsonProperty @JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY) data class TokenForBasicAuthentication( @JsonProperty("access_token") var access_token: String = "", - @JsonProperty("token_type") var tokenType: String = "" + @JsonProperty("token_type") var tokenType: String = "", ) { fun fetchToken() = "$tokenType $access_token".trim() } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/Exceptions.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/Exceptions.kt index 1552176e..ca51b96d 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/Exceptions.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/Exceptions.kt @@ -55,7 +55,7 @@ class JournalpostHarIkkeKommetIRetur(message: String) : RuntimeException(message class KunneIkkeJournalforeOpprettetJournalpost(message: String) : RuntimeException(message) class LagreSaksbehandlerIdentForJournalfortJournalpostFeilet( message: String, - throwable: Throwable + throwable: Throwable, ) : RuntimeException(message, throwable) class KunneIkkeKnytteSakTilJournalpost(message: String, throwable: Throwable) : @@ -66,17 +66,15 @@ class JournalfortJournalpostManglerJournalfortAvIdent(message: String) : Runtime class HentJournalpostFeilet(message: String, throwable: Throwable) : RuntimeException(message, throwable) -fun fantIkkeDokument(forsendelseId: String, dokumentreferanse: String?): Nothing = - throw HttpClientErrorException( - HttpStatus.BAD_REQUEST, - "Finnes ingen dokument $dokumentreferanse i forsendelse $forsendelseId" - ) - -fun kanIkkeHenteJournalMedUgyldigFagomrade(ugyldigFagomrade: String): Nothing = - throw HttpClientErrorException( - HttpStatus.BAD_REQUEST, - "Kan ikke hente journal med tema $ugyldigFagomrade. Gyldige verdier er BID og FAR" - ) +fun fantIkkeDokument(forsendelseId: String, dokumentreferanse: String?): Nothing = throw HttpClientErrorException( + HttpStatus.BAD_REQUEST, + "Finnes ingen dokument $dokumentreferanse i forsendelse $forsendelseId", +) + +fun kanIkkeHenteJournalMedUgyldigFagomrade(ugyldigFagomrade: String): Nothing = throw HttpClientErrorException( + HttpStatus.BAD_REQUEST, + "Kan ikke hente journal med tema $ugyldigFagomrade. Gyldige verdier er BID og FAR", +) inline fun runCatchingIgnoreException(block: () -> R): R? { return try { diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JoarkHendelse.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JoarkHendelse.kt index b0cf73ab..fd69303f 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JoarkHendelse.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JoarkHendelse.kt @@ -9,7 +9,8 @@ enum class JoarkHendelseType(val hendelsesType: String) { TEMA_ENDRET("TemaEndret"), ENDELIG_JOURNALFORT("EndeligJournalført"), JOURNALPOST_UTGATT("JournalpostUtgått"), - UKJENT("Ukjent"); + UKJENT("Ukjent"), + ; private fun erAv(hendelsesType: CharSequence?): Boolean { return hendelsesType != null && hendelsesType.toString().compareTo(this.hendelsesType, ignoreCase = true) == 0 diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JournalpostHendelseIntern.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JournalpostHendelseIntern.kt index 6b1cb87b..d5eef0fa 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JournalpostHendelseIntern.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/JournalpostHendelseIntern.kt @@ -14,7 +14,7 @@ import no.nav.joarkjournalfoeringhendelser.JournalfoeringHendelseRecord class JournalpostHendelseIntern( var journalpost: Journalpost, var saksbehandler: SaksbehandlerMedEnhet?, - var journalforingHendelse: JournalfoeringHendelseRecord? + var journalforingHendelse: JournalfoeringHendelseRecord?, ) { val journalpostHendelse: JournalpostHendelse @@ -35,7 +35,7 @@ class JournalpostHendelseIntern( journalfortDato = journalpost.hentDatoJournalfort(), hendelseType = if (journalforingHendelse?.hendelsesType == JoarkHendelseType.ENDELIG_JOURNALFORT.hendelsesType) HendelseType.JOURNALFORING else HendelseType.ENDRING, journalposttype = journalpost.journalposttype?.name, - behandlingstema = journalpost.behandlingstema + behandlingstema = journalpost.behandlingstema, ) } @@ -60,7 +60,7 @@ class JournalpostHendelseIntern( CorrelationId.fetchCorrelationIdForThread(), saksbehandler?.saksbehandler?.ident, saksbehandler?.saksbehandler?.navn, - saksbehandler?.enhetsnummer + saksbehandler?.enhetsnummer, ) fun hentJournalpostHendelse() = journalpostHendelse @@ -74,7 +74,7 @@ class JournalforingHendelseIntern(var journalforingHendelse: JournalfoeringHende return JournalpostHendelseIntern( journalpost, hentSaksbehandler(journalpost), - journalforingHendelse + journalforingHendelse, ).hentJournalpostHendelse() } @@ -85,7 +85,7 @@ class JournalforingHendelseIntern(var journalforingHendelse: JournalfoeringHende if (journalpost.isStatusJournalfort()) { return Saksbehandler( journalpost.hentJournalfortAvIdent(), - journalpost.journalfortAvNavn + journalpost.journalfortAvNavn, ).tilEnhet(journalpost.journalforendeEnhet) } @@ -103,7 +103,7 @@ class JournalforingHendelseIntern(var journalforingHendelse: JournalfoeringHende else -> null }, enhet = null, - fagomrade = journalforingHendelse.temaNytt ?: journalforingHendelse.temaGammelt + fagomrade = journalforingHendelse.temaNytt ?: journalforingHendelse.temaGammelt, ) } @@ -111,6 +111,6 @@ class JournalforingHendelseIntern(var journalforingHendelse: JournalfoeringHende CorrelationId.fetchCorrelationIdForThread(), saksbehandler.saksbehandler.ident, saksbehandler.saksbehandler.navn, - saksbehandler.enhetsnummer + saksbehandler.enhetsnummer, ) } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/OppgaveHendelse.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/OppgaveHendelse.kt index f64c9380..d04f56a6 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/OppgaveHendelse.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/OppgaveHendelse.kt @@ -31,14 +31,14 @@ data class OppgaveHendelse( val aktivDato: LocalDate? = null, val opprettetTidspunkt: ZonedDateTime? = null, val ferdigstiltTidspunkt: ZonedDateTime? = null, - val endretTidspunkt: ZonedDateTime? = null + val endretTidspunkt: ZonedDateTime? = null, ) { @JsonIgnoreProperties(ignoreUnknown = true) data class Ident( var identType: OppgaveIdentType? = null, val verdi: String? = null, - val folkeregisterident: String? = null + val folkeregisterident: String? = null, ) fun erTemaBIDEllerFAR(): Boolean = tema == "BID" || tema == "FAR" @@ -48,27 +48,29 @@ data class OppgaveHendelse( fun erJoarkJournalpost(): Boolean = journalpostId != null && !journalpostId.contains("BID") - override fun toString(): String = "{id=$id,journalpostId=$journalpostId,tema=$tema,opprettetAv=$opprettetAv,tildeltEnhetsnr=$tildeltEnhetsnr,fristFerdigstillelse=$fristFerdigstillelse,status=$status,statuskategori=$statuskategori,saksreferanse=$saksreferanse}" + override fun toString(): String = + "{id=$id,journalpostId=$journalpostId,tema=$tema,opprettetAv=$opprettetAv,tildeltEnhetsnr=$tildeltEnhetsnr,fristFerdigstillelse=$fristFerdigstillelse,status=$status,statuskategori=$statuskategori,saksreferanse=$saksreferanse}" } enum class Prioritet { - HOY // , NORM, LAV + HOY, // , NORM, LAV } enum class OppgaveIdentType { AKTOERID, ORGNR, SAMHANDLERNR, - BNR + BNR, } enum class OppgaveStatus { FERDIGSTILT, AAPNET, OPPRETTET, FEILREGISTRERT, - UNDER_BEHANDLING + UNDER_BEHANDLING, } enum class Oppgavestatuskategori { - AAPEN, AVSLUTTET + AAPEN, + AVSLUTTET, } diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/ResourceByDiscriminator.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/ResourceByDiscriminator.kt index 0c73cee1..6e007094 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/ResourceByDiscriminator.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/model/ResourceByDiscriminator.kt @@ -14,7 +14,8 @@ class ResourceByDiscriminator(private val resources: Map) { } enum class Discriminator { - REGULAR_USER, SERVICE_USER; + REGULAR_USER, + SERVICE_USER, } inline fun Boolean?.ifFalse(block: Boolean?.() -> Unit): Boolean? { diff --git a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/utils/JsonMapper.kt b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/utils/JsonMapper.kt index d6f1a9f4..fedd5e88 100644 --- a/src/main/kotlin/no/nav/bidrag/dokument/arkiv/utils/JsonMapper.kt +++ b/src/main/kotlin/no/nav/bidrag/dokument/arkiv/utils/JsonMapper.kt @@ -11,7 +11,12 @@ object JsonMapper { return try { StaticContextAccessor.getBean(ObjectMapper::class.java).readValue(jsonString) } catch (e: Exception) { - LoggerFactory.getLogger(JsonMapper::class.java).error("Det skjedde en feil ved deserialisering json string ved bruk av ObjectMapper fra spring context. Bruker egendefinert ObjectMapper", e) + LoggerFactory.getLogger( + JsonMapper::class.java, + ).error( + "Det skjedde en feil ved deserialisering json string ved bruk av ObjectMapper fra spring context. Bruker egendefinert ObjectMapper", + e, + ) ObjectMapper().registerModule(kotlinModule()).readValue(jsonString) } } @@ -20,7 +25,12 @@ object JsonMapper { return try { StaticContextAccessor.getBean(ObjectMapper::class.java).writeValueAsString(dataObject) } catch (e: Exception) { - LoggerFactory.getLogger(JsonMapper::class.java).error("Det skjedde en feil ved serialisering av json objekt ved bruk av ObjectMapper fra Spring context. Bruker egendefinert ObjectMapper", e) + LoggerFactory.getLogger( + JsonMapper::class.java, + ).error( + "Det skjedde en feil ved serialisering av json objekt ved bruk av ObjectMapper fra Spring context. Bruker egendefinert ObjectMapper", + e, + ) ObjectMapper().registerModule(kotlinModule()).writeValueAsString(dataObject) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/JsonMapperTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/JsonMapperTest.kt index 0b4b7fe4..ee73e70f 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/JsonMapperTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/JsonMapperTest.kt @@ -43,85 +43,85 @@ internal class JsonMapperTest { gjelder = "1234", tittel = "Tittelen på journalposten", gjelderType = IdentType.FNR, - tilknyttSaker = listOf("sakIdent") + tilknyttSaker = listOf("sakIdent"), ) val endreJournalpostIntern = EndreJournalpostCommandIntern(endreJournalpostCommand, "4805") val oppdaterJp = LagreJournalpostRequest(12345, endreJournalpostIntern, journalpost) val jsonMap = objectMapper.convertValue( oppdaterJp, - MutableMap::class.java + MutableMap::class.java, ) as Map val jsonObjects = JsonObjects(jsonMap) org.junit.jupiter.api.Assertions.assertAll( Executable { Assertions.assertThat( - jsonObjects.objekt("avsenderMottaker")!!["navn"] + jsonObjects.objekt("avsenderMottaker")!!["navn"], ) .`as`("avsenderMottaker") .isEqualTo("AvsenderNavn") }, Executable { Assertions.assertThat( - jsonObjects.objekt("bruker")!!["id"] + jsonObjects.objekt("bruker")!!["id"], ).`as`("id").isEqualTo("1234") }, Executable { Assertions.assertThat( - jsonObjects.objekt("bruker")!!["idType"] + jsonObjects.objekt("bruker")!!["idType"], ).`as`("idType").isEqualTo("FNR") }, Executable { Assertions.assertThat( - jsonObjects.objekt("sak")!!["fagsakId"] + jsonObjects.objekt("sak")!!["fagsakId"], ) .`as`("fagsakId") .isEqualTo("sakIdent") }, Executable { Assertions.assertThat( - jsonObjects.objekt("sak")!!["fagsaksystem"] + jsonObjects.objekt("sak")!!["fagsaksystem"], ) .`as`("fagsaksystem") .isEqualTo("BISYS") }, Executable { Assertions.assertThat( - jsonObjects.objekt("sak")!!["sakstype"] + jsonObjects.objekt("sak")!!["sakstype"], ) .`as`("fagsaksystem") .isEqualTo("FAGSAK") }, Executable { Assertions.assertThat( - jsonObjects.listeMedObjekter("dokumenter")!![0]["dokumentInfoId"] + jsonObjects.listeMedObjekter("dokumenter")!![0]["dokumentInfoId"], ) .`as`("dokumentInfoId") .isEqualTo("55555") }, Executable { Assertions.assertThat( - jsonObjects.listeMedObjekter("dokumenter")!![0]["tittel"] + jsonObjects.listeMedObjekter("dokumenter")!![0]["tittel"], ) .`as`("tittel") .isEqualTo("Tittelen på dokument") }, Executable { Assertions.assertThat( - jsonMap["tema"] + jsonMap["tema"], ).`as`("tema").isEqualTo("BID") }, Executable { Assertions.assertThat( - jsonMap["tittel"] + jsonMap["tittel"], ).`as`("tittel").isEqualTo("Tittelen på journalposten") - } + }, ) } @Test @DisplayName("skal mappe json streng til java.util.Map") @Throws( - JsonProcessingException::class + JsonProcessingException::class, ) fun skalMappeJsonRequest() { val opprettJournalpostRequestAsJson = java.lang.String.join( @@ -138,72 +138,72 @@ internal class JsonMapperTest { "\"sak\": { \"arkivsaksnummer\": \"1900001\", \"arkivsaksystem\": \"GSAK\" },", "\"tema\": \"BID\",", "\"tittel\": \"Tittelen på journalposten\"", - "}" + "}", ) val jsonMap: Map<*, *> = objectMapper.readValue( opprettJournalpostRequestAsJson, - MutableMap::class.java + MutableMap::class.java, ) org.junit.jupiter.api.Assertions.assertAll( Executable { Assertions.assertThat( - jsonMap["avsenderMottaker"] + jsonMap["avsenderMottaker"], ).`as`("avsenderMottaker").isNotNull() }, Executable { Assertions.assertThat( - jsonMap["behandlingstema"] + jsonMap["behandlingstema"], ).`as`("behandlingstema").isEqualTo("BI01") }, Executable { Assertions.assertThat( - jsonMap["bruker"] + jsonMap["bruker"], ).`as`("bruker").isNotNull() }, Executable { Assertions.assertThat( - jsonMap["dokumenter"] + jsonMap["dokumenter"], ).`as`("dokumenter").isNotNull() }, Executable { Assertions.assertThat( - jsonMap["eksternReferanseId"] + jsonMap["eksternReferanseId"], ) .`as`("eksternReferanseId") .isEqualTo("dokreferanse") }, Executable { Assertions.assertThat( - jsonMap["journalfoerendeEnhet"] + jsonMap["journalfoerendeEnhet"], ) .`as`("journalfoerendeEnhet") .isEqualTo("666") }, Executable { Assertions.assertThat( - jsonMap["journalpostType"] + jsonMap["journalpostType"], ).`as`("journalpostType").isEqualTo("N") }, Executable { Assertions.assertThat( - jsonMap["kanal"] + jsonMap["kanal"], ).`as`("kanal").isEqualTo("nav.no") }, Executable { Assertions.assertThat( - jsonMap["sak"] + jsonMap["sak"], ).`as`("sak").isNotNull() }, Executable { Assertions.assertThat( - jsonMap["tema"] + jsonMap["tema"], ).`as`("tema").isEqualTo("BID") }, Executable { Assertions.assertThat( - jsonMap["tittel"] + jsonMap["tittel"], ).`as`("tittel").isEqualTo("Tittelen på journalposten") - } + }, ) } @@ -223,7 +223,7 @@ internal class JsonMapperTest { .`as`("Variables") .containsEntry("fagsakId", "666") .containsEntry("tema", listOf("BID")) - } + }, ) } @@ -241,7 +241,7 @@ internal class JsonMapperTest { Assertions.assertThat(safQuery.getVariables()) .`as`("Variables") .containsEntry("journalpostId", 1235L) - } + }, ) } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AbstractControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AbstractControllerTest.kt index 1b0be63e..7311808d 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AbstractControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AbstractControllerTest.kt @@ -30,7 +30,7 @@ import org.springframework.test.context.ActiveProfiles @DisplayName("JournalpostController") @SpringBootTest( classes = [BidragDokumentArkivTest::class], - webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT + webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, ) @AutoConfigureWireMock(port = 0) @EnableMockOAuth2Server diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AvvikControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AvvikControllerTest.kt index 7266856c..c967695e 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AvvikControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/AvvikControllerTest.kt @@ -59,8 +59,8 @@ class AvvikControllerTest : AbstractControllerTest() { BestemKanalResponse( regel = "", regelBegrunnelse = "", - distribusjonskanal = DistribusjonsKanal.PRINT - ) + distribusjonskanal = DistribusjonsKanal.PRINT, + ), ) } @@ -73,7 +73,7 @@ class AvvikControllerTest : AbstractControllerTest() { val journalpostIdFraJson = 201028011L val avvikHendelse = createAvvikHendelse( AvvikType.OVERFOR_TIL_ANNEN_ENHET, - java.util.Map.of("nyttEnhetsnummer", overforTilEnhet) + java.util.Map.of("nyttEnhetsnummer", overforTilEnhet), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(responseJournalpostJson, HttpStatus.OK) @@ -87,14 +87,14 @@ class AvvikControllerTest : AbstractControllerTest() { overforEnhetResponse.statusCode shouldBe HttpStatus.OK stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, - String.format("\"journalfoerendeEnhet\":\"%s\"", overforTilEnhet) + String.format("\"journalfoerendeEnhet\":\"%s\"", overforTilEnhet), ) Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdFraJson" + "JOARK-$journalpostIdFraJson", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } } @@ -113,16 +113,16 @@ class AvvikControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL + tittel = DOKUMENT_1_TITTEL, ), Dokument( dokumentInfoId = "123213", - tittel = "tittel" - ) + tittel = "tittel", + ), ), tema = "FAR", - journalstatus = JournalStatus.JOURNALFOERT - ) + journalstatus = JournalStatus.JOURNALFOERT, + ), ) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) stubs.mockDokarkivOppdaterRequest(journalpostIdFraJson) @@ -133,14 +133,14 @@ class AvvikControllerTest : AbstractControllerTest() { response.statusCode shouldBe HttpStatus.OK stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, - "\"tittel\":\"FARSKAP UTELUKKET: Tittel på dokument 1\",\"dokumenter\":[{\"dokumentInfoId\":\"123123\",\"tittel\":\"FARSKAP UTELUKKET: Tittel på dokument 1\"}]" + "\"tittel\":\"FARSKAP UTELUKKET: Tittel på dokument 1\",\"dokumenter\":[{\"dokumentInfoId\":\"123123\",\"tittel\":\"FARSKAP UTELUKKET: Tittel på dokument 1\"}]", ) Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdFraJson" + "JOARK-$journalpostIdFraJson", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } } @@ -151,17 +151,17 @@ class AvvikControllerTest : AbstractControllerTest() { val xEnhet = "1234" val avvikHendelse = createAvvikHendelse( AvvikType.REGISTRER_RETUR, - java.util.Map.of("returDato", "2023-03-01") + java.util.Map.of("returDato", "2023-03-01"), ).copy( - beskrivelse = "DEtte er test" + beskrivelse = "DEtte er test", ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost( opprettSafResponse().copy( kanal = JournalpostKanal.LOKAL_UTSKRIFT, journalstatus = JournalStatus.EKSPEDERT, - journalposttype = JournalpostType.U - ) + journalposttype = JournalpostType.U, + ), ) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) stubs.mockDokarkivOppdaterRequest(JOURNALPOST_ID) @@ -172,7 +172,7 @@ class AvvikControllerTest : AbstractControllerTest() { registrerReturRespons.statusCode shouldBe HttpStatus.OK stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, - "tilleggsopplysninger\":[{\"nokkel\":\"retur0_2023-03-01\",\"verdi\":\"DEtte er test\"}]" + "tilleggsopplysninger\":[{\"nokkel\":\"retur0_2023-03-01\",\"verdi\":\"DEtte er test\"}]", ) } } @@ -181,7 +181,7 @@ class AvvikControllerTest : AbstractControllerTest() { @DisplayName("skal ikke sende journalpostHendelse når avvik OVER_TIL_ANNEN_ENHET feiler") @Throws( IOException::class, - JSONException::class + JSONException::class, ) fun shouldNotSendeKafkaMessageWhenAvvikFails() { // given @@ -190,7 +190,7 @@ class AvvikControllerTest : AbstractControllerTest() { val journalpostIdFraJson = 201028011L val avvikHendelse = createAvvikHendelse( AvvikType.OVERFOR_TIL_ANNEN_ENHET, - java.util.Map.of("nyttEnhetsnummer", overforTilEnhet) + java.util.Map.of("nyttEnhetsnummer", overforTilEnhet), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(responseJournalpostJson, HttpStatus.OK) @@ -210,13 +210,13 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, - String.format("\"journalfoerendeEnhet\":\"%s\"", overforTilEnhet) + String.format("\"journalfoerendeEnhet\":\"%s\"", overforTilEnhet), ) }, { Mockito.verify(kafkaTemplateMock, Mockito.never()) .send(ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any()) - } + }, ) } @@ -230,7 +230,7 @@ class AvvikControllerTest : AbstractControllerTest() { val nyttFagomrade = "FAR" val avvikHendelse = createAvvikHendelse( AvvikType.ENDRE_FAGOMRADE, - java.util.Map.of("fagomrade", nyttFagomrade) + java.util.Map.of("fagomrade", nyttFagomrade), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockOrganisasjonGeografiskTilknytning(geografiskEnhet) @@ -251,18 +251,18 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, - String.format("\"tema\":\"%s\"", nyttFagomrade) + String.format("\"tema\":\"%s\"", nyttFagomrade), ) }, { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$JOURNALPOST_ID" + "JOARK-$JOURNALPOST_ID", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -273,7 +273,7 @@ class AvvikControllerTest : AbstractControllerTest() { val nyttFagomrade = "BID" val avvikHendelse = createAvvikHendelse( AvvikType.ENDRE_FAGOMRADE, - java.util.Map.of("fagomrade", nyttFagomrade) + java.util.Map.of("fagomrade", nyttFagomrade), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockOrganisasjonGeografiskTilknytning(geografiskEnhet) @@ -287,14 +287,14 @@ class AvvikControllerTest : AbstractControllerTest() { overforEnhetResponse.statusCode shouldBe HttpStatus.OK stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, - String.format("\"tema\":\"%s\"", nyttFagomrade) + String.format("\"tema\":\"%s\"", nyttFagomrade), ) Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$JOURNALPOST_ID" + "JOARK-$JOURNALPOST_ID", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } } @@ -308,7 +308,7 @@ class AvvikControllerTest : AbstractControllerTest() { val nyttFagomrade = "FAR" val avvikHendelse = createAvvikHendelse( AvvikType.ENDRE_FAGOMRADE, - java.util.Map.of("fagomrade", nyttFagomrade) + java.util.Map.of("fagomrade", nyttFagomrade), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseDokumentOversiktFagsak() @@ -335,18 +335,18 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, - "\"tilleggsopplysninger\":[{\"nokkel\":\"avvikEndretTema\",\"verdi\":\"true\"}]" + "\"tilleggsopplysninger\":[{\"nokkel\":\"avvikEndretTema\",\"verdi\":\"true\"}]", ) }, { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$JOURNALPOST_ID" + "JOARK-$JOURNALPOST_ID", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -358,7 +358,7 @@ class AvvikControllerTest : AbstractControllerTest() { val nyttFagomrade = "FAR" val avvikHendelse = createAvvikHendelse( AvvikType.ENDRE_FAGOMRADE, - java.util.Map.of("fagomrade", nyttFagomrade) + java.util.Map.of("fagomrade", nyttFagomrade), ) val tilleggsOpplysninger = TilleggsOpplysninger() @@ -371,25 +371,25 @@ class AvvikControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( tittel = DOKUMENT_1_TITTEL, - dokumentInfoId = DOKUMENT_1_ID - ) + dokumentInfoId = DOKUMENT_1_ID, + ), ), journalstatus = JournalStatus.JOURNALFOERT, - tema = "BID" + tema = "BID", ), opprettSafResponse( journalpostId = JOURNALPOST_ID_3.toString(), dokumenter = listOf( Dokument( tittel = DOKUMENT_1_TITTEL, - dokumentInfoId = DOKUMENT_1_ID - ) + dokumentInfoId = DOKUMENT_1_ID, + ), ), tema = "FAR", journalstatus = JournalStatus.FEILREGISTRERT, - tilleggsopplysninger = tilleggsOpplysninger - ) - ) + tilleggsopplysninger = tilleggsOpplysninger, + ), + ), ) stubs.mockSafResponseHentJournalpost(opprettSafResponse(journalstatus = JournalStatus.JOURNALFOERT)) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -417,18 +417,18 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID_3, - "\"tilleggsopplysninger\":[{\"nokkel\":\"avvikEndretTema\",\"verdi\":\"false\"}]" + "\"tilleggsopplysninger\":[{\"nokkel\":\"avvikEndretTema\",\"verdi\":\"false\"}]", ) }, { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$JOURNALPOST_ID" + "JOARK-$JOURNALPOST_ID", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -442,13 +442,13 @@ class AvvikControllerTest : AbstractControllerTest() { val nyJournalpostId = 301028011L val avvikHendelse = createAvvikHendelse( AvvikType.ENDRE_FAGOMRADE, - java.util.Map.of("fagomrade", nyttFagomrade) + java.util.Map.of("fagomrade", nyttFagomrade), ) val journalpost = opprettSafResponse(originalJournalpostId.toString()) .copy( journalstatus = JournalStatus.JOURNALFOERT, relevanteDatoer = listOf(DATO_DOKUMENT, DATO_REGISTRERT), - kanal = JournalpostKanal.NAV_NO + kanal = JournalpostKanal.NAV_NO, ) stubs.mockSafResponseHentJournalpost(journalpost) @@ -481,7 +481,7 @@ class AvvikControllerTest : AbstractControllerTest() { "\"datoMottatt\":\"2021-04-20\"," + "\"bruker\":{\"id\":\"123213213213\",\"idType\":\"AKTOERID\"}," + "\"dokumenter\":[{\"tittel\":\"Tittel på dokument 1\",\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"SlZCRVJpMHhMamNnUW1GelpUWTBJR1Z1WTI5a1pYUWdabmx6YVhOcklHUnZhM1Z0Wlc1MA==\"}]}]," + - "\"avsenderMottaker\":{\"navn\":\"Avsender Avsendersen\",\"id\":\"112312385076492416\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"navn\":\"Avsender Avsendersen\",\"id\":\"112312385076492416\",\"idType\":\"FNR\"}}", ) }, { stubs.verifyStub.oppgaveOpprettIkkeKalt() }, @@ -490,11 +490,11 @@ class AvvikControllerTest : AbstractControllerTest() { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$originalJournalpostId" + "JOARK-$originalJournalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -528,11 +528,11 @@ class AvvikControllerTest : AbstractControllerTest() { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdFraJson" + "JOARK-$journalpostIdFraJson", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -547,7 +547,7 @@ class AvvikControllerTest : AbstractControllerTest() { val avvikHendelse = createAvvikHendelse(AvvikType.TREKK_JOURNALPOST, java.util.Map.of()).copy( beskrivelse = "En begrunnelse", - detaljer = detaljer + detaljer = detaljer, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost( @@ -556,14 +556,14 @@ class AvvikControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL + tittel = DOKUMENT_1_TITTEL, ), Dokument( dokumentInfoId = "123213", - tittel = "tittel" - ) - ) - ) + tittel = "tittel", + ), + ), + ), ) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) stubs.mockDokarkivFeilregistrerRequest(journalpostIdFraJson) @@ -586,7 +586,7 @@ class AvvikControllerTest : AbstractControllerTest() { stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, "\"tittel\":\"Tittel på dokument 1 (En begrunnelse)\"", - "\"dokumenter\":[{\"dokumentInfoId\":\"123123\",\"tittel\":\"Tittel på dokument 1 (En begrunnelse)\"}]" + "\"dokumenter\":[{\"dokumentInfoId\":\"123123\",\"tittel\":\"Tittel på dokument 1 (En begrunnelse)\"}]", ) }, { stubs.verifyStub.dokarkivFerdigstillKalt(journalpostIdFraJson) }, @@ -594,11 +594,11 @@ class AvvikControllerTest : AbstractControllerTest() { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdFraJson" + "JOARK-$journalpostIdFraJson", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -613,7 +613,7 @@ class AvvikControllerTest : AbstractControllerTest() { val avvikHendelse = createAvvikHendelse(AvvikType.TREKK_JOURNALPOST, java.util.Map.of()) .copy( detaljer = detaljer, - beskrivelse = "En begrunnelse" + beskrivelse = "En begrunnelse", ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost( @@ -623,22 +623,22 @@ class AvvikControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL + tittel = DOKUMENT_1_TITTEL, ), Dokument( dokumentInfoId = "123213", - tittel = "tittel" - ) - ) - ) + tittel = "tittel", + ), + ), + ), ) stubs.mockPersonResponse( PersonDto( PERSON_IDENT, aktørId = AKTOR_IDENT, - navn = FulltNavn("Personnavn") + navn = FulltNavn("Personnavn"), ), - HttpStatus.OK + HttpStatus.OK, ) stubs.mockDokarkivFeilregistrerRequest(journalpostIdFraJson) stubs.mockDokarkivOppdaterRequest(journalpostIdFraJson) @@ -662,7 +662,7 @@ class AvvikControllerTest : AbstractControllerTest() { stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, "\"tittel\":\"Tittel på dokument 1 (En begrunnelse)\"", - "\"dokumenter\":[{\"dokumentInfoId\":\"123123\",\"tittel\":\"Tittel på dokument 1 (En begrunnelse)\"}]" + "\"dokumenter\":[{\"dokumentInfoId\":\"123123\",\"tittel\":\"Tittel på dokument 1 (En begrunnelse)\"}]", ) }, { stubs.verifyStub.dokarkivFerdigstillKalt(journalpostIdFraJson) }, @@ -670,11 +670,11 @@ class AvvikControllerTest : AbstractControllerTest() { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdFraJson" + "JOARK-$journalpostIdFraJson", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -697,8 +697,8 @@ class AvvikControllerTest : AbstractControllerTest() { stubs.mockSafResponseTilknyttedeJournalposter( listOf( TilknyttetJournalpost(journalpostId, JournalStatus.FERDIGSTILT, Sak("5276661")), - TilknyttetJournalpost(journalpostId2, JournalStatus.FERDIGSTILT, Sak("5376661")) - ) + TilknyttetJournalpost(journalpostId2, JournalStatus.FERDIGSTILT, Sak("5376661")), + ), ) val overforEnhetResponse = sendAvvikRequest(xEnhet, journalpostId, avvikHendelse) @@ -713,24 +713,24 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterDistribusjonsInfoKalt( journalpostId, - JournalpostKanal.INGEN_DISTRIBUSJON + JournalpostKanal.INGEN_DISTRIBUSJON, ) }, { stubs.verifyStub.dokarkivOppdaterDistribusjonsInfoKalt( journalpostId2, - JournalpostKanal.INGEN_DISTRIBUSJON + JournalpostKanal.INGEN_DISTRIBUSJON, ) }, { Mockito.verify(kafkaTemplateMock, times(0)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -747,7 +747,7 @@ class AvvikControllerTest : AbstractControllerTest() { adresselinje1 = "Adresselinje1", land = "NO", postnummer = "3000", - poststed = "OSLO" + poststed = "OSLO", ) val safResponse = opprettUtgaendeDistribuertSafResponse(journalpostId = journalpostId.toString()) @@ -756,13 +756,13 @@ class AvvikControllerTest : AbstractControllerTest() { val avvikHendelse = createAvvikHendelse(AvvikType.BESTILL_NY_DISTRIBUSJON, emptyMap()) .copy( - adresse = postadresse + adresse = postadresse, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(journalpostId = newJournalpostId.toString()), - newJournalpostId + newJournalpostId, ) stubs.mockSafHentDokumentResponse() stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -775,9 +775,9 @@ class AvvikControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak(sakId) - ) - ) + Sak(sakId), + ), + ), ) val overforEnhetResponse = sendAvvikRequest(xEnhet, journalpostId, avvikHendelse) @@ -790,13 +790,13 @@ class AvvikControllerTest : AbstractControllerTest() { stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"nokkel\":\"retur0_2021-08-18\",\"verdi\":\"Returpost\"}" + "{\"nokkel\":\"retur0_2021-08-18\",\"verdi\":\"Returpost\"}", ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}", - "{\"nokkel\":\"avvikNyDistribusjon\",\"verdi\":\"true\"}" + "{\"nokkel\":\"avvikNyDistribusjon\",\"verdi\":\"true\"}", ) stubs.verifyStub.dokdistFordelingKalt( @@ -811,16 +811,16 @@ class AvvikControllerTest : AbstractControllerTest() { postadresse.adresselinje3, postadresse.land, postadresse.postnummer, - postadresse.poststed + postadresse.poststed, ), - null - ) - ) + null, + ), + ), ) stubs.verifyStub.dokarkivOppdaterKalt( newJournalpostId, - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}", ) stubs.verifyStub.dokarkivOpprettKalt( @@ -837,18 +837,18 @@ class AvvikControllerTest : AbstractControllerTest() { "{\"tittel\":\"Tittel på dokument 1\"," + "\"dokumentvarianter\":[" + "{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"${ - Base64.getEncoder().encodeToString(DOKUMENT_FIL.encodeToByteArray()) + Base64.getEncoder().encodeToString(DOKUMENT_FIL.encodeToByteArray()) }\"}]}]," + - "\"avsenderMottaker\":{\"navn\":\"Avsender Avsendersen\",\"id\":\"112312385076492416\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"navn\":\"Avsender Avsendersen\",\"id\":\"112312385076492416\",\"idType\":\"FNR\"}}", ) stubs.verifyStub.safHentDokumentKalt(journalpostId, DOKUMENT_1_ID.toLong()) Mockito.verify(kafkaTemplateMock, times(0)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } } @@ -862,7 +862,7 @@ class AvvikControllerTest : AbstractControllerTest() { safResponse.kanal = JournalpostKanal.SKAN_IM val avvikHendelse = createAvvikHendelse(AvvikType.BESTILL_RESKANNING, mapOf()) .copy( - beskrivelse = "Innholdet er uleselig" + beskrivelse = "Innholdet er uleselig", ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -888,7 +888,7 @@ class AvvikControllerTest : AbstractControllerTest() { stubs.verifyStub.oppgaveOppdaterKalt( 1, "\"id\":${jfrOppgave.id}", - "\"endretAvEnhetsnr\":\"1234\"" + "\"endretAvEnhetsnr\":\"1234\"", ) }, { @@ -898,24 +898,24 @@ class AvvikControllerTest : AbstractControllerTest() { "\\nVi ber om reskanning av dokument." + "\\nBeskrivelse fra saksbehandler: " + "\\nInnholdet er uleselig" + - "\\r\\n\\r\\nBeskrivelse som var der fra før\"" + "\\r\\n\\r\\nBeskrivelse som var der fra før\"", ) }, { stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "\"journalfoerendeEnhet\":\"2950\"" + "\"journalfoerendeEnhet\":\"2950\"", ) }, { Mockito.verify(kafkaTemplateMock, times(1)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -930,7 +930,7 @@ class AvvikControllerTest : AbstractControllerTest() { val avvikHendelse = createAvvikHendelse(AvvikType.BESTILL_SPLITTING, mapOf("enhetsnummer" to xEnhet)) .copy( - beskrivelse = "Jeg ønsker å splitte etter side 5" + beskrivelse = "Jeg ønsker å splitte etter side 5", ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -942,7 +942,7 @@ class AvvikControllerTest : AbstractControllerTest() { .copy( tildeltEnhetsnr = "4806", beskrivelse = "Beskrivelse som var der fra før", - tilordnetRessurs = "Z999999" + tilordnetRessurs = "Z999999", ) stubs.mockSokOppgave(OppgaveSokResponse(1, listOf(jfrOppgave)), HttpStatus.OK) val overforEnhetResponse = sendAvvikRequest(xEnhet, journalpostId, avvikHendelse) @@ -960,7 +960,7 @@ class AvvikControllerTest : AbstractControllerTest() { stubs.verifyStub.oppgaveOppdaterKalt( 1, "\"id\":${jfrOppgave.id}", - "\"endretAvEnhetsnr\":\"1234\"" + "\"endretAvEnhetsnr\":\"1234\"", ) }, { @@ -969,24 +969,24 @@ class AvvikControllerTest : AbstractControllerTest() { "Bestill splitting av dokument:" + " \\nSaksbehandler ønsker splitting av dokument:" + "\\nJeg ønsker å splitte etter side 5" + - "\\r\\n\\r\\nBeskrivelse som var der fra før\"" + "\\r\\n\\r\\nBeskrivelse som var der fra før\"", ) }, { stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "\"journalfoerendeEnhet\":\"2950\"" + "\"journalfoerendeEnhet\":\"2950\"", ) }, { Mockito.verify(kafkaTemplateMock, times(1)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -1000,7 +1000,7 @@ class AvvikControllerTest : AbstractControllerTest() { safResponse.journalforendeEnhet = OppgaveEnhet.FAGPOST val avvikHendelse = createAvvikHendelse(AvvikType.BESTILL_SPLITTING, mapOf()) .copy( - beskrivelse = "Jeg ønsker å splitte etter side 5" + beskrivelse = "Jeg ønsker å splitte etter side 5", ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -1010,7 +1010,7 @@ class AvvikControllerTest : AbstractControllerTest() { val jfrOppgave = createOppgaveDataWithJournalpostId(journalpostId.toString()).copy( tildeltEnhetsnr = OppgaveEnhet.FAGPOST, - beskrivelse = "Beskrivelse som var der fra før" + beskrivelse = "Beskrivelse som var der fra før", ) stubs.mockSokOppgave(OppgaveSokResponse(1, listOf(jfrOppgave)), HttpStatus.OK) val overforEnhetResponse = sendAvvikRequest(xEnhet, journalpostId, avvikHendelse) @@ -1030,11 +1030,11 @@ class AvvikControllerTest : AbstractControllerTest() { Mockito.verify(kafkaTemplateMock, times(1)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -1050,7 +1050,7 @@ class AvvikControllerTest : AbstractControllerTest() { safResponse.journalstatus = JournalStatus.JOURNALFOERT val avvikHendelse = createAvvikHendelse(AvvikType.BESTILL_RESKANNING, mapOf()) .copy( - beskrivelse = null + beskrivelse = null, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -1061,7 +1061,7 @@ class AvvikControllerTest : AbstractControllerTest() { val jfrOppgave = createOppgaveDataWithJournalpostId(journalpostId.toString()) .copy( - beskrivelse = "Beskrivelse som var der fra før" + beskrivelse = "Beskrivelse som var der fra før", ) stubs.mockSokOppgave(OppgaveSokResponse(1, listOf(jfrOppgave)), HttpStatus.OK) val overforEnhetResponse = sendAvvikRequest(xEnhet, journalpostId, avvikHendelse) @@ -1082,23 +1082,23 @@ class AvvikControllerTest : AbstractControllerTest() { "\"tema\":\"GEN\"", "\"aktoerId\":\"$AKTOR_IDENT\"", "\"saksreferanse\":\"$sak\"", - "\"journalpostId\":\"$journalpostId\"" + "\"journalpostId\":\"$journalpostId\"", ) }, { stubs.verifyStub.oppgaveOpprettKalt( - "Bestill reskanning: \\nVi ber om reskanning av dokument.\\nBeskrivelse fra saksbehandler: \\nIngen\"" + "Bestill reskanning: \\nVi ber om reskanning av dokument.\\nBeskrivelse fra saksbehandler: \\nIngen\"", ) }, { Mockito.verify(kafkaTemplateMock, times(1)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -1114,7 +1114,7 @@ class AvvikControllerTest : AbstractControllerTest() { safResponse.journalstatus = JournalStatus.JOURNALFOERT val avvikHendelse = createAvvikHendelse(AvvikType.BESTILL_SPLITTING, mapOf()) .copy( - beskrivelse = "Jeg ønsker å splitte etter side 5" + beskrivelse = "Jeg ønsker å splitte etter side 5", ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -1125,7 +1125,7 @@ class AvvikControllerTest : AbstractControllerTest() { val jfrOppgave = createOppgaveDataWithJournalpostId(journalpostId.toString()) .copy( - beskrivelse = "Beskrivelse som var der fra før" + beskrivelse = "Beskrivelse som var der fra før", ) stubs.mockSokOppgave(OppgaveSokResponse(1, listOf(jfrOppgave)), HttpStatus.OK) val overforEnhetResponse = sendAvvikRequest(xEnhet, journalpostId, avvikHendelse) @@ -1146,25 +1146,25 @@ class AvvikControllerTest : AbstractControllerTest() { "\"tema\":\"GEN\"", "\"aktoerId\":\"$AKTOR_IDENT\"", "\"saksreferanse\":\"$sak\"", - "\"journalpostId\":\"$journalpostId\"" + "\"journalpostId\":\"$journalpostId\"", ) }, { stubs.verifyStub.oppgaveOpprettKalt( "Bestill splitting av dokument: " + "\\nSaksbehandler ønsker splitting av dokument:" + - "\\nJeg ønsker å splitte etter side 5" + "\\nJeg ønsker å splitte etter side 5", ) }, { Mockito.verify(kafkaTemplateMock, times(1)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -1195,7 +1195,7 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"tilleggsopplysninger\":[{\"nokkel\":\"originalBestilt\",\"verdi\":\"true\"}],\"dokumenter\":[]}" + "{\"tilleggsopplysninger\":[{\"nokkel\":\"originalBestilt\",\"verdi\":\"true\"}],\"dokumenter\":[]}", ) }, { @@ -1205,24 +1205,24 @@ class AvvikControllerTest : AbstractControllerTest() { "\"tema\":\"GEN\"", "\"aktoerId\":\"92345678910\"", "\"saksreferanse\":\"5276661\"", - "\"journalpostId\":\"201028011\"" + "\"journalpostId\":\"201028011\"", ) }, { stubs.verifyStub.oppgaveOpprettKalt( "Originalbestilling: Vi ber om å få tilsendt papiroriginalen av vedlagte dokumenter. " + - "\\n \\nDokumentet skal sendes til 1234, og merkes med aud-localhost - navn\"" + "\\n \\nDokumentet skal sendes til 1234, og merkes med aud-localhost - navn\"", ) }, { Mockito.verify(kafkaTemplateMock, times(1)).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostId" + "JOARK-$journalpostId", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -1236,7 +1236,7 @@ class AvvikControllerTest : AbstractControllerTest() { val vurderDokumentOppgave = createOppgaveDataWithJournalpostId(journalpostIdAnnenFagomrade.toString()) .copy( - oppgavetype = "VUR" + oppgavetype = "VUR", ) val sak1 = "2132131" val sak2 = "213213213" @@ -1251,11 +1251,11 @@ class AvvikControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = tittelOriginalDokument - ) + tittel = tittelOriginalDokument, + ), ), tittel = tittelOriginalDokument, - journalstatus = JournalStatus.JOURNALFOERT + journalstatus = JournalStatus.JOURNALFOERT, ) safResponseAnnenFagomrade.tema = "BAR" safResponseAnnenFagomrade.sak = Sak("51233aA", "IT01") @@ -1263,33 +1263,33 @@ class AvvikControllerTest : AbstractControllerTest() { val avvikHendelse = createAvvikHendelse( AvvikType.KOPIER_FRA_ANNEN_FAGOMRADE, - java.util.Map.of("knyttTilSaker", "$sak1,$sak2") + java.util.Map.of("knyttTilSaker", "$sak1,$sak2"), ).copy( dokumenter = listOf( DokumentDto( dokumentreferanse = DOKUMENT_1_ID, - tittel = tittelDokument1 + tittel = tittelDokument1, ), DokumentDto( dokumentreferanse = null, tittel = tittelDokument2, - dokument = dokumentData2 - ) - ) + dokument = dokumentData2, + ), + ), ) stubs.mockSafResponseTilknyttedeJournalposter( listOf( TilknyttetJournalpost(newJournalpostId, JournalStatus.FERDIGSTILT, Sak(sak1)), - TilknyttetJournalpost(journalpostId2, JournalStatus.FERDIGSTILT, Sak(sak2)) - ) + TilknyttetJournalpost(journalpostId2, JournalStatus.FERDIGSTILT, Sak(sak2)), + ), ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = newJournalpostId.toString(), - sak = Sak(sak1) + sak = Sak(sak1), ), - newJournalpostId + newJournalpostId, ) stubs.mockSafHentDokumentResponse() stubs.mockSokOppgave(OppgaveSokResponse(1, listOf(vurderDokumentOppgave)), HttpStatus.OK) @@ -1313,7 +1313,7 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( newJournalpostId, - "{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"aud-localhost\"}" + "{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"aud-localhost\"}", ) }, { @@ -1334,31 +1334,31 @@ class AvvikControllerTest : AbstractControllerTest() { "\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"SlZCRVJpMHhMamNnUW1GelpUWTBJR1Z1WTI5a1pYUWdabmx6YVhOcklHUnZhM1Z0Wlc1MA==\"}]}," + "{\"tittel\":\"$tittelDokument2\"," + "\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"$dokumentData2=\"}]}]," + - "\"avsenderMottaker\":{\"navn\":\"Avsender Avsendersen\",\"id\":\"112312385076492416\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"navn\":\"Avsender Avsendersen\",\"id\":\"112312385076492416\",\"idType\":\"FNR\"}}", ) }, { stubs.verifyStub.dokarkivTilknyttSakerKalt(newJournalpostId, sak2) }, { stubs.verifyStub.oppgaveOppdaterKalt( 1, - "{\"id\":2,\"versjon\":1,\"endretAvEnhetsnr\":\"$xEnhet\",\"status\":\"FERDIGSTILT\"}" + "{\"id\":2,\"versjon\":1,\"endretAvEnhetsnr\":\"$xEnhet\",\"status\":\"FERDIGSTILT\"}", ) }, { stubs.verifyStub.safHentDokumentKalt( journalpostIdAnnenFagomrade, - DOKUMENT_1_ID.toLong() + DOKUMENT_1_ID.toLong(), ) }, { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdAnnenFagomrade" + "JOARK-$journalpostIdAnnenFagomrade", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } @@ -1371,7 +1371,7 @@ class AvvikControllerTest : AbstractControllerTest() { val vurderDokumentOppgave = createOppgaveDataWithJournalpostId(journalpostIdAnnenFagomrade.toString()) .copy( - oppgavetype = "VUR" + oppgavetype = "VUR", ) val sak1 = "2132131" val sak2 = "213213213" @@ -1382,10 +1382,10 @@ class AvvikControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = "Tittel på original dokument" - ) + tittel = "Tittel på original dokument", + ), ), - journalstatus = JournalStatus.JOURNALFOERT + journalstatus = JournalStatus.JOURNALFOERT, ) safResponseAnnenFagomrade.tema = "BAR" safResponseAnnenFagomrade.sak = Sak("51233aA", "IT01") @@ -1393,30 +1393,30 @@ class AvvikControllerTest : AbstractControllerTest() { val avvikHendelse = createAvvikHendelse( AvvikType.KOPIER_FRA_ANNEN_FAGOMRADE, - java.util.Map.of("knyttTilSaker", "$sak1,$sak2") + java.util.Map.of("knyttTilSaker", "$sak1,$sak2"), ).copy( dokumenter = listOf( DokumentDto( DOKUMENT_1_ID, - tittel = tittelDokument1 - ) - ) + tittel = tittelDokument1, + ), + ), ) stubs.mockSafResponseTilknyttedeJournalposter(listOf()) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = newJournalpostId.toString(), - sak = Sak(sak1) + sak = Sak(sak1), ), - newJournalpostId + newJournalpostId, ) stubs.mockSafHentDokumentResponse() stubs.mockSokOppgave(OppgaveSokResponse(1, listOf(vurderDokumentOppgave)), HttpStatus.OK) stubs.mockDokarkivTilknyttRequest( newJournalpostId, 123213, - HttpStatus.INTERNAL_SERVER_ERROR + HttpStatus.INTERNAL_SERVER_ERROR, ) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) stubs.mockDokarkivOppdaterRequest(newJournalpostId) @@ -1441,43 +1441,36 @@ class AvvikControllerTest : AbstractControllerTest() { { stubs.verifyStub.safHentDokumentKalt( journalpostIdAnnenFagomrade, - DOKUMENT_1_ID.toLong() + DOKUMENT_1_ID.toLong(), ) }, { Mockito.verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq( - "JOARK-$journalpostIdAnnenFagomrade" + "JOARK-$journalpostIdAnnenFagomrade", ), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) - } + }, ) } - private fun sendAvvikRequest( - enhet: String, - journalpostId: Long, - avvikHendelse: Avvikshendelse - ): ResponseEntity { + private fun sendAvvikRequest(enhet: String, journalpostId: Long, avvikHendelse: Avvikshendelse): ResponseEntity { val headersMedEnhet = HttpHeaders() headersMedEnhet.add(EnhetFilter.X_ENHET_HEADER, enhet) return httpHeaderTestRestTemplate.exchange( initUrl() + "/journal/JOARK-" + journalpostId + "/avvik", HttpMethod.POST, HttpEntity(avvikHendelse, headersMedEnhet), - BehandleAvvikshendelseResponse::class.java + BehandleAvvikshendelseResponse::class.java, ) } - private fun createAvvikHendelse( - avvikType: AvvikType, - detaljer: Map - ): Avvikshendelse { + private fun createAvvikHendelse(avvikType: AvvikType, detaljer: Map): Avvikshendelse { return Avvikshendelse( avvikType = avvikType, - detaljer = detaljer + detaljer = detaljer, ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerControllerTest.kt index 37171789..23903c1d 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DistribuerControllerTest.kt @@ -61,8 +61,8 @@ internal class DistribuerControllerTest : AbstractControllerTest() { BestemKanalResponse( regel = "", regelBegrunnelse = "", - distribusjonskanal = DistribusjonsKanal.PRINT - ) + distribusjonskanal = DistribusjonsKanal.PRINT, + ), ) } @@ -81,33 +81,33 @@ internal class DistribuerControllerTest : AbstractControllerTest() { tilleggsopplysningerEtterDist.add( mapOf( "nokkel" to "dokdistBestillingsId", - "verdi" to "asdsadasdsadasdasd" - ) + "verdi" to "asdsadasdsadasdasd", + ), ) stubs.mockBestmDistribusjonskanal( BestemKanalResponse( regel = "", regelBegrunnelse = "", - distribusjonskanal = DistribusjonsKanal.PRINT - ) + distribusjonskanal = DistribusjonsKanal.PRINT, + ), ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsopplysninger, - relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")), ), null, - "ETTER_DIST" + "ETTER_DIST", ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysningerEtterDist), "ETTER_DIST", - "ETTER_DIST2" + "ETTER_DIST2", ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysningerEtterDist), "ETTER_DIST2", - "ETTER_DIST3" + "ETTER_DIST3", ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(JOURNALPOST_ID) @@ -116,14 +116,14 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( JOURNALPOST_ID, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) val distribuerTilAdresse = createDistribuerTilAdresse() .copy( adresselinje2 = "Adresselinje2", - adresselinje3 = "Adresselinje3" + adresselinje3 = "Adresselinje3", ) val request = DistribuerJournalpostRequest(adresse = distribuerTilAdresse) @@ -131,7 +131,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { // when val response = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + JOURNALPOST_ID, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) // then @@ -144,20 +144,20 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "BI01A01", null, request.adresse, - null - ) - ) + null, + ), + ), ) stubs.verifyStub.dokdistFordelingKalt(DistribusjonsType.VEDTAK.name) stubs.verifyStub.dokdistFordelingKalt(DistribusjonsTidspunkt.KJERNETID.name) stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, request.adresse!!.adresselinje1, - request.adresse!!.land + request.adresse!!.land, ) stubs.verifyStub.dokarkivIkkeOppdaterKalt( JOURNALPOST_ID, - "datoDokument" + "datoDokument", ) stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, @@ -166,7 +166,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"}," + "{\"nokkel\":\"distAdresse0\",\"verdi\":\"{\\\"adresselinje1\\\":\\\"Adresselinje1\\\",\\\"adresselinje2\\\":\\\"Adresselinje2\\\",\\\"adresselinje3\\\":\\\"Adresselinje3\\\",\\\"la\"}," + "{\"nokkel\":\"distAdresse1\",\"verdi\":\"nd\\\":\\\"NO\\\",\\\"postnummer\\\":\\\"3000\\\",\\\"poststed\\\":\\\"Ingen\\\"}\"}," + - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}", ) } } @@ -186,34 +186,34 @@ internal class DistribuerControllerTest : AbstractControllerTest() { tilleggsopplysningerEtterDist.add( mapOf( "nokkel" to "dokdistBestillingsId", - "verdi" to "asdsadasdsadasdasd" - ) + "verdi" to "asdsadasdsadasdasd", + ), ) stubs.mockBestmDistribusjonskanal( BestemKanalResponse( regel = "", regelBegrunnelse = "", - distribusjonskanal = DistribusjonsKanal.DITT_NAV - ) + distribusjonskanal = DistribusjonsKanal.DITT_NAV, + ), ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsopplysninger, - relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")), ), null, - "ETTER_DIST" + "ETTER_DIST", ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysningerEtterDist), "ETTER_DIST", - "ETTER_DIST2" + "ETTER_DIST2", ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysningerEtterDist), "ETTER_DIST2", - "ETTER_DIST3" + "ETTER_DIST3", ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(JOURNALPOST_ID) @@ -222,14 +222,14 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( JOURNALPOST_ID, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) // when val response = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + JOURNALPOST_ID, - HttpEntity(null, headersMedEnhet) + HttpEntity(null, headersMedEnhet), ) // then @@ -242,18 +242,18 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "BI01A01", null, null, - null - ) - ) + null, + ), + ), ) stubs.verifyStub.dokdistFordelingKalt(DistribusjonsType.VEDTAK.name) stubs.verifyStub.dokdistFordelingKalt(DistribusjonsTidspunkt.KJERNETID.name) stubs.verifyStub.dokarkivOppdaterKalt( - JOURNALPOST_ID + JOURNALPOST_ID, ) stubs.verifyStub.dokarkivIkkeOppdaterKalt( JOURNALPOST_ID, - "datoDokument" + "datoDokument", ) stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, @@ -261,7 +261,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "{\"nokkel\":\"dokdistBestillingsId\",\"verdi\":\"asdsadasdsadasdasd\"}," + "{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + "{\"nokkel\":\"origDistDigitalt\",\"verdi\":\"true\"}," + - "{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}" + "{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}", ) } } @@ -281,24 +281,24 @@ internal class DistribuerControllerTest : AbstractControllerTest() { tilleggsopplysningerEtterDist.add( mapOf( "nokkel" to "dokdistBestillingsId", - "verdi" to "asdsadasdsadasdasd" - ) + "verdi" to "asdsadasdsadasdasd", + ), ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysninger), null, - "ETTER_DIST" + "ETTER_DIST", ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysningerEtterDist), "ETTER_DIST", - "ETTER_DIST2" + "ETTER_DIST2", ) stubs.mockSafResponseHentJournalpost( opprettUtgaendeSafResponse(tilleggsopplysninger = tilleggsopplysningerEtterDist), "ETTER_DIST2", - "ETTER_DIST3" + "ETTER_DIST3", ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(JOURNALPOST_ID) @@ -307,20 +307,20 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( JOURNALPOST_ID, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) val distribuerTilAdresse = createDistribuerTilAdresse().copy( adresselinje2 = "Adresselinje2", - adresselinje3 = "Adresselinje3" + adresselinje3 = "Adresselinje3", ) val request = DistribuerJournalpostRequest(adresse = distribuerTilAdresse) // when val response = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + JOURNALPOST_ID, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) // then @@ -333,20 +333,20 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "BI01A01", null, request.adresse, - null - ) - ) + null, + ), + ), ) stubs.verifyStub.dokdistFordelingKalt(DistribusjonsType.VEDTAK.name) stubs.verifyStub.dokdistFordelingKalt(DistribusjonsTidspunkt.KJERNETID.name) stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, request.adresse!!.adresselinje1, - request.adresse!!.land + request.adresse!!.land, ) stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, - "datoDokument" + "datoDokument", ) stubs.verifyStub.dokarkivOppdaterKalt( JOURNALPOST_ID, @@ -355,7 +355,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"}," + "{\"nokkel\":\"distAdresse0\",\"verdi\":\"{\\\"adresselinje1\\\":\\\"Adresselinje1\\\",\\\"adresselinje2\\\":\\\"Adresselinje2\\\",\\\"adresselinje3\\\":\\\"Adresselinje3\\\",\\\"la\"}," + "{\"nokkel\":\"distAdresse1\",\"verdi\":\"nd\\\":\\\"NO\\\",\\\"postnummer\\\":\\\"3000\\\",\\\"poststed\\\":\\\"Ingen\\\"}\"}," + - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}", ) } } @@ -372,7 +372,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { journalpostId.toString(), journalpostType = JournalpostType.U, journalstatus = JournalStatus.FERDIGSTILT, - avsenderMottaker = AvsenderMottaker(navn = "Samhandler Navnesen") + avsenderMottaker = AvsenderMottaker(navn = "Samhandler Navnesen"), ) .copy(tema = "FAR") stubs.mockSafResponseHentJournalpost(safresponse) @@ -383,21 +383,21 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) val distribuerTilAdresse = createDistribuerTilAdresse() .copy( adresselinje2 = "Adresselinje2", - adresselinje3 = "Adresselinje3" + adresselinje3 = "Adresselinje3", ) val request = DistribuerJournalpostRequest(adresse = distribuerTilAdresse) // when val response = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + journalpostId, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) @@ -410,13 +410,13 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "BI01A06", null, request.adresse, - null - ) - ) + null, + ), + ), ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}", ) } } @@ -435,7 +435,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { journalpostId.toString(), journalpostType = JournalpostType.U, journalstatus = JournalStatus.FERDIGSTILT, - avsenderMottaker = AvsenderMottaker(navn = "Samhandler Navnesen") + avsenderMottaker = AvsenderMottaker(navn = "Samhandler Navnesen"), ) stubs.mockSafResponseHentJournalpost(safresponse) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) @@ -445,21 +445,21 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) val distribuerTilAdresse = createDistribuerTilAdresse() .copy( adresselinje2 = "Adresselinje2", - adresselinje3 = "Adresselinje3" + adresselinje3 = "Adresselinje3", ) val request = DistribuerJournalpostRequest(adresse = distribuerTilAdresse) // when val response = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + journalpostId, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) assertSoftly { @@ -471,13 +471,13 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "BI01A06", null, request.adresse, - null - ) - ) + null, + ), + ), ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}", ) } } @@ -496,12 +496,12 @@ internal class DistribuerControllerTest : AbstractControllerTest() { journalposttype = "U", kanal = JournalpostKanal.NAV_NO, utsendingsinfo = UtsendingsInfo( - digitalpostSendt = DigitalpostSendt("test@nav.no") + digitalpostSendt = DigitalpostSendt("test@nav.no"), ), tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DATO_DOKUMENT) + relevanteDatoer = listOf(DATO_DOKUMENT), ), - journalpostId + journalpostId, ) // when val response = @@ -535,12 +535,12 @@ internal class DistribuerControllerTest : AbstractControllerTest() { journalposttype = "U", kanal = JournalpostKanal.NAV_NO, utsendingsinfo = UtsendingsInfo( - epostVarselSendt = EpostVarselSendt("test@nav.no", "tittel", "varslingtekst") + epostVarselSendt = EpostVarselSendt("test@nav.no", "tittel", "varslingtekst"), ), tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DATO_DOKUMENT) + relevanteDatoer = listOf(DATO_DOKUMENT), ), - journalpostId + journalpostId, ) // when val response = @@ -572,7 +572,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { val safresponse = opprettSafResponse( journalpostId.toString(), journalpostType = JournalpostType.U, - journalstatus = JournalStatus.FERDIGSTILT + journalstatus = JournalStatus.FERDIGSTILT, ) stubs.mockSafResponseHentJournalpost(safresponse) val tilleggsOpplysninger = TilleggsOpplysninger() @@ -580,10 +580,10 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.mockSafResponseHentJournalpost( safresponse.copy( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")), ), null, - "ETTER_DIST" + "ETTER_DIST", ) stubs.mockSafResponseHentJournalpost( safresponse.copy( @@ -595,10 +595,10 @@ internal class DistribuerControllerTest : AbstractControllerTest() { } else { dokument } - } + }, ), "ETTER_DIST", - null + null, ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -607,9 +607,9 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) stubs.mockDokarkivOppdaterDistribusjonsInfoRequest(journalpostId) val request = DistribuerJournalpostRequest(lokalUtskrift = true) @@ -619,7 +619,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { initUrl() + "/journal/distribuer/JOARK-" + journalpostId, HttpMethod.POST, HttpEntity(request, headersMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -628,15 +628,15 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.verifyStub.dokdistFordelingIkkeKalt() stubs.verifyStub.dokarkivOppdaterDistribusjonsInfoKalt( journalpostId, - "{\"settStatusEkspedert\":true,\"utsendingsKanal\":\"L\"}" + "{\"settStatusEkspedert\":true,\"utsendingsKanal\":\"L\"}", ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"tilleggsopplysninger\":[{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}" + "{\"tilleggsopplysninger\":[{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}", ) stubs.verifyStub.dokarkivIkkeOppdaterKalt( journalpostId, - "{\"dokumenter\":[{\"dokumentInfoId\":\"$DOKUMENT_1_ID\",\"tittel\":\"Tittel på dokument 1 (dokumentet er sendt per post med vedlegg)\"}]}" + "{\"dokumenter\":[{\"dokumentInfoId\":\"$DOKUMENT_1_ID\",\"tittel\":\"Tittel på dokument 1 (dokumentet er sendt per post med vedlegg)\"}]}", ) } } @@ -652,7 +652,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { val safresponse = opprettSafResponse( journalpostId.toString(), journalpostType = JournalpostType.U, - journalstatus = JournalStatus.FERDIGSTILT + journalstatus = JournalStatus.FERDIGSTILT, ) stubs.mockSafResponseHentJournalpost(safresponse) val tilleggsOpplysninger = TilleggsOpplysninger() @@ -660,18 +660,18 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.mockSafResponseHentJournalpost( safresponse.copy( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")), ), null, - "ETTER_DIST" + "ETTER_DIST", ) stubs.mockSafResponseHentJournalpost( safresponse.copy( tilleggsopplysninger = tilleggsOpplysninger, - journalstatus = JournalStatus.EKSPEDERT + journalstatus = JournalStatus.EKSPEDERT, ), "ETTER_DIST", - null + null, ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -680,9 +680,9 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) stubs.mockDokarkivOppdaterDistribusjonsInfoRequest(journalpostId) val request = DistribuerJournalpostRequest(lokalUtskrift = true) @@ -692,7 +692,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { initUrl() + "/journal/distribuer/JOARK-" + journalpostId, HttpMethod.POST, HttpEntity(request, headersMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -701,15 +701,15 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.verifyStub.dokdistFordelingIkkeKalt() stubs.verifyStub.dokarkivOppdaterDistribusjonsInfoKalt( journalpostId, - "{\"settStatusEkspedert\":true,\"utsendingsKanal\":\"L\"}" + "{\"settStatusEkspedert\":true,\"utsendingsKanal\":\"L\"}", ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"tilleggsopplysninger\":[{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}" + "{\"tilleggsopplysninger\":[{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}", ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"dokumenter\":[{\"dokumentInfoId\":\"$DOKUMENT_1_ID\",\"tittel\":\"Tittel på dokument 1 (dokumentet er sendt per post med vedlegg)\"}]}" + "{\"dokumenter\":[{\"dokumentInfoId\":\"$DOKUMENT_1_ID\",\"tittel\":\"Tittel på dokument 1 (dokumentet er sendt per post med vedlegg)\"}]}", ) } } @@ -726,7 +726,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { journalpostId.toString(), journalpostType = JournalpostType.U, journalstatus = JournalStatus.FERDIGSTILT, - tema = "FAR" + tema = "FAR", ) stubs.mockSafResponseHentJournalpost(safresponse) val tilleggsOpplysninger = TilleggsOpplysninger() @@ -734,18 +734,18 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.mockSafResponseHentJournalpost( safresponse.copy( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType(LocalDateTime.now().toString(), "DATO_DOKUMENT")), ), null, - "ETTER_DIST" + "ETTER_DIST", ) stubs.mockSafResponseHentJournalpost( safresponse.copy( tilleggsopplysninger = tilleggsOpplysninger, - journalstatus = JournalStatus.EKSPEDERT + journalstatus = JournalStatus.EKSPEDERT, ), "ETTER_DIST", - null + null, ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -754,9 +754,9 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) stubs.mockDokarkivOppdaterDistribusjonsInfoRequest(journalpostId) val request = DistribuerJournalpostRequest(lokalUtskrift = true) @@ -766,7 +766,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { initUrl() + "/journal/distribuer/JOARK-" + journalpostId, HttpMethod.POST, HttpEntity(request, headersMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -775,15 +775,15 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.verifyStub.dokdistFordelingIkkeKalt() stubs.verifyStub.dokarkivOppdaterDistribusjonsInfoKalt( journalpostId, - "{\"settStatusEkspedert\":true,\"utsendingsKanal\":\"L\"}" + "{\"settStatusEkspedert\":true,\"utsendingsKanal\":\"L\"}", ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, - "{\"tilleggsopplysninger\":[{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}" + "{\"tilleggsopplysninger\":[{\"nokkel\":\"journalfortAvIdent\",\"verdi\":\"Z99999\"},{\"nokkel\":\"distribuertAvIdent\",\"verdi\":\"aud-localhost\"}],\"dokumenter\":[]}", ) stubs.verifyStub.dokarkivIkkeOppdaterKalt( journalpostId, - "{\"dokumenter\":[{\"dokumentInfoId\":\"$DOKUMENT_1_ID\",\"tittel\":\"Tittel på dokument 1 (dokumentet er sendt per post med vedlegg)\"}]}" + "{\"dokumenter\":[{\"dokumentInfoId\":\"$DOKUMENT_1_ID\",\"tittel\":\"Tittel på dokument 1 (dokumentet er sendt per post med vedlegg)\"}]}", ) } } @@ -803,7 +803,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.mockDokarkivOppdaterRequest(journalpostIdFraJson) val distribuerTilAdresse = createDistribuerTilAdresse().copy( adresselinje2 = "Adresselinje2", - adresselinje3 = "Adresselinje3" + adresselinje3 = "Adresselinje3", ) val request = DistribuerJournalpostRequest(adresse = distribuerTilAdresse) @@ -812,7 +812,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { val oppdaterJournalpostResponseEntity = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + journalpostIdFraJson, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) // then @@ -830,7 +830,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { .`as`("journalpostId") .isEqualTo("JOARK-201028011") }, - { stubs.verifyStub.dokdistFordelingIkkeKalt() } + { stubs.verifyStub.dokdistFordelingIkkeKalt() }, ) } @@ -853,7 +853,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { postnummer = Postnummer("3939"), poststed = Poststed("OSLO"), land = Landkode2("NO"), - land3 = Landkode3("NOR") + land3 = Landkode3("NOR"), ) headersMedEnhet.add(EnhetFilter.X_ENHET_HEADER, xEnhet) @@ -865,15 +865,17 @@ internal class DistribuerControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostIdFraJson, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) stubs.mockPersonAdresseResponse(postadresse) // when val oppdaterJournalpostResponseEntity = - httpHeaderTestRestTemplate.postForEntity(initUrl() + "/journal/distribuer/JOARK-" + journalpostIdFraJson + "?batchId=" + batchId) + httpHeaderTestRestTemplate.postForEntity( + initUrl() + "/journal/distribuer/JOARK-" + journalpostIdFraJson + "?batchId=" + batchId, + ) // then org.junit.jupiter.api.Assertions.assertAll( @@ -896,11 +898,11 @@ internal class DistribuerControllerTest : AbstractControllerTest() { postadresse.adresselinje3?.verdi, postadresse.land.verdi, postadresse.postnummer?.verdi, - postadresse.poststed?.verdi + postadresse.poststed?.verdi, ), - batchId - ) - ) + batchId, + ), + ), ) }, { stubs.verifyStub.dokdistFordelingKalt(DistribusjonsType.VEDTAK.name) }, @@ -911,9 +913,9 @@ internal class DistribuerControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}", ) - } + }, ) } @@ -929,7 +931,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { headersMedEnhet.add(EnhetFilter.X_ENHET_HEADER, xEnhet) stubs.mockSafResponseHentJournalpost( "journalpostSafUtgaaendeResponseVedtakTittel.json", - HttpStatus.OK + HttpStatus.OK, ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockDokarkivOppdaterRequest(journalpostIdFraJson) @@ -937,7 +939,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { val distribuerTilAdresse = createDistribuerTilAdresse() .copy( adresselinje2 = "Adresselinje2", - adresselinje3 = "Adresselinje3" + adresselinje3 = "Adresselinje3", ) val request = DistribuerJournalpostRequest(adresse = distribuerTilAdresse) @@ -945,7 +947,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { val oppdaterJournalpostResponseEntity = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + journalpostIdFraJson, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) // then @@ -964,9 +966,9 @@ internal class DistribuerControllerTest : AbstractControllerTest() { "BI01H03", "Brev som inneholder Vedtak", request.adresse, - null - ) - ) + null, + ), + ), ) }, { stubs.verifyStub.dokdistFordelingKalt(DistribusjonsType.VEDTAK.name) }, @@ -975,15 +977,15 @@ internal class DistribuerControllerTest : AbstractControllerTest() { stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, request.adresse!!.adresselinje1, - request.adresse!!.land + request.adresse!!.land, ) }, { stubs.verifyStub.dokarkivOppdaterKalt( journalpostIdFraJson, - "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}" + "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}", ) - } + }, ) } @@ -999,7 +1001,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { headersMedEnhet.add(EnhetFilter.X_ENHET_HEADER, xEnhet) stubs.mockSafResponseHentJournalpost( "journalpostSafUtgaaendeResponseNoMottaker.json", - HttpStatus.OK + HttpStatus.OK, ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) @@ -1009,7 +1011,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { val oppdaterJournalpostResponseEntity = httpHeaderTestRestTemplate.postForEntity( initUrl() + "/journal/distribuer/JOARK-" + journalpostIdFraJson, - HttpEntity(request, headersMedEnhet) + HttpEntity(request, headersMedEnhet), ) // then @@ -1020,7 +1022,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { .`as`("statusCode") .isEqualTo(HttpStatus.BAD_REQUEST) }, - { stubs.verifyStub.dokdistFordelingIkkeKalt() } + { stubs.verifyStub.dokdistFordelingIkkeKalt() }, ) } @@ -1048,7 +1050,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { .extracting { it.statusCode } .`as`("statusCode") .isEqualTo(HttpStatus.OK) - } + }, ) } @@ -1064,13 +1066,13 @@ internal class DistribuerControllerTest : AbstractControllerTest() { headersMedEnhet.add(EnhetFilter.X_ENHET_HEADER, xEnhet) stubs.mockSafResponseHentJournalpost( "journalpostSafUtgaaendeResponseNoMottaker.json", - HttpStatus.OK + HttpStatus.OK, ) stubs.mockDokdistFordelingRequest(HttpStatus.OK, bestillingId) // when val response = httpHeaderTestRestTemplate.getForEntity( initUrl() + "/journal/distribuer/JOARK-" + journalpostIdFraJson + "/enabled", - HttpEntity(headersMedEnhet) + HttpEntity(headersMedEnhet), ) // then @@ -1080,7 +1082,7 @@ internal class DistribuerControllerTest : AbstractControllerTest() { .extracting { it.statusCode } .`as`("statusCode") .isEqualTo(HttpStatus.NOT_ACCEPTABLE) - } + }, ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DokumentControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DokumentControllerTest.kt index d069a10f..5b1fa445 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DokumentControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/DokumentControllerTest.kt @@ -42,13 +42,13 @@ class DokumentControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL + tittel = DOKUMENT_1_TITTEL, ), Dokument( dokumentInfoId = DOKUMENT_2_ID, - tittel = DOKUMENT_1_TITTEL - ) - ) + tittel = DOKUMENT_1_TITTEL, + ), + ), ) stubs.mockSafResponseTilknyttedeJournalposter( @@ -56,9 +56,9 @@ class DokumentControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("123") - ) - ) + Sak("123"), + ), + ), ) stubs.mockSafHentDokumentResponse() stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -67,7 +67,7 @@ class DokumentControllerTest : AbstractControllerTest() { initUrl() + "/dokument/JOARK-$journalpostId/$DOKUMENT_1_ID", HttpMethod.OPTIONS, null, - object : ParameterizedTypeReference>() {} + object : ParameterizedTypeReference>() {}, ) response.statusCode shouldBe HttpStatus.OK @@ -89,13 +89,13 @@ class DokumentControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL + tittel = DOKUMENT_1_TITTEL, ), Dokument( dokumentInfoId = DOKUMENT_2_ID, - tittel = DOKUMENT_1_TITTEL - ) - ) + tittel = DOKUMENT_1_TITTEL, + ), + ), ) stubs.mockSafResponseTilknyttedeJournalposter( @@ -103,9 +103,9 @@ class DokumentControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("123") - ) - ) + Sak("123"), + ), + ), ) stubs.mockSafHentDokumentResponse() stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -114,7 +114,7 @@ class DokumentControllerTest : AbstractControllerTest() { initUrl() + "/dokumentreferanse/$DOKUMENT_1_ID", HttpMethod.OPTIONS, null, - object : ParameterizedTypeReference>() {} + object : ParameterizedTypeReference>() {}, ) response.statusCode shouldBe HttpStatus.OK @@ -136,13 +136,13 @@ class DokumentControllerTest : AbstractControllerTest() { dokumenter = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL + tittel = DOKUMENT_1_TITTEL, ), Dokument( dokumentInfoId = DOKUMENT_2_ID, - tittel = DOKUMENT_1_TITTEL - ) - ) + tittel = DOKUMENT_1_TITTEL, + ), + ), ) stubs.mockSafResponseTilknyttedeJournalposter( @@ -150,9 +150,9 @@ class DokumentControllerTest : AbstractControllerTest() { TilknyttetJournalpost( journalpostId, JournalStatus.FERDIGSTILT, - Sak("123") - ) - ) + Sak("123"), + ), + ), ) stubs.mockSafHentDokumentResponse() stubs.mockSafResponseHentJournalpost(safResponse, journalpostId) @@ -161,7 +161,7 @@ class DokumentControllerTest : AbstractControllerTest() { initUrl() + "/dokument/JOARK-$journalpostId", HttpMethod.OPTIONS, null, - object : ParameterizedTypeReference>() {} + object : ParameterizedTypeReference>() {}, ) response.statusCode shouldBe HttpStatus.OK diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/EndreJournalpostControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/EndreJournalpostControllerTest.kt index 0edd127b..bc238750 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/EndreJournalpostControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/EndreJournalpostControllerTest.kt @@ -43,8 +43,8 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { gjelder = "06127412345", tittel = "So Tired", endreDokumenter = listOf( - EndreDokument("BLABLA", "1", "1", "In a galazy far far away") - ) + EndreDokument("BLABLA", "1", "1", "In a galazy far far away"), + ), ) return endreJournalpostCommand } @@ -58,15 +58,15 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { .copy( skalJournalfores = false, tittel = "Ny tittel", - dokumentDato = LocalDate.now().plusDays(2) + dokumentDato = LocalDate.now().plusDays(2), ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = journalpostId.toString(), journalpostType = JournalpostType.N, - sak = Sak("123") - ) + sak = Sak("123"), + ), ) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -77,7 +77,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headerMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -94,15 +94,15 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { val endreJournalpostCommand: EndreJournalpostCommand = createEndreJournalpostCommand().copy( skalJournalfores = false, tittel = "Ny tittel", - dokumentDato = LocalDate.parse("2022-05-20") + dokumentDato = LocalDate.parse("2022-05-20"), ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = journalpostId.toString(), journalpostType = JournalpostType.N, - sak = Sak("123") - ) + sak = Sak("123"), + ), ) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -113,7 +113,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headerMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -122,7 +122,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, "\"tittel\":\"Ny tittel\"", - "\"datoDokument\":\"2022-05-20T00:00\"" + "\"datoDokument\":\"2022-05-20T00:00\"", ) } } @@ -138,26 +138,26 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { .copy( skalJournalfores = true, tittel = "Ny tittel", - tilknyttSaker = listOf(sak) + tilknyttSaker = listOf(sak), ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = journalpostId.toString(), - sak = null + sak = null, ), null, - "AFTER" + "AFTER", ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = journalpostId.toString(), tittel = endreJournalpostCommand.tittel!!, journalstatus = JournalStatus.JOURNALFOERT, - sak = Sak(sak) + sak = Sak(sak), ), "AFTER", - null + null, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -170,7 +170,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headerMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -189,10 +189,10 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { "\"sakstype\":\"FAGSAK\"", "\"bruker\":{\"id\":\"06127412345\",\"idType\":\"FNR\"}", "\"avsenderMottaker\":{\"navn\":\"Dauden, Svarte\"}", - "\"dokumenter\":[{\"dokumentInfoId\":\"1\",\"tittel\":\"In a galazy far far away\",\"brevkode\":\"BLABLA\"}]" + "\"dokumenter\":[{\"dokumentInfoId\":\"1\",\"tittel\":\"In a galazy far far away\",\"brevkode\":\"BLABLA\"}]", ) }, - { stubs.verifyStub.dokarkivFerdigstillKalt(journalpostId) } + { stubs.verifyStub.dokarkivFerdigstillKalt(journalpostId) }, ) } @@ -200,7 +200,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { @DisplayName("skal endre og journalføre journalpost med flere saker") @Throws( IOException::class, - JSONException::class + JSONException::class, ) fun skalEndreOgJournalforeJournalpostMedFlereSaker() { val saksnummer1 = "200000" @@ -212,23 +212,23 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { .copy( skalJournalfores = true, gjelder = "12333333333", - tilknyttSaker = listOf(saksnummer1, saksnummer2) + tilknyttSaker = listOf(saksnummer1, saksnummer2), ) stubs.mockSokOppgave( OppgaveSokResponse( 1, - listOf(createOppgaveDataWithSaksnummer(saksnummer3)) + listOf(createOppgaveDataWithSaksnummer(saksnummer3)), ), - HttpStatus.OK + HttpStatus.OK, ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = journalpostId.toString(), - sak = null + sak = null, ), null, - "AFTER" + "AFTER", ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( @@ -236,10 +236,10 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { journalstatus = JournalStatus.JOURNALFOERT, sak = Sak(saksnummer1), bruker = Bruker(endreJournalpostCommand.gjelder, "FNR"), - journalforendeEnhet = "4806" + journalforendeEnhet = "4806", ), "AFTER", - null + null, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -252,7 +252,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headerMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -270,10 +270,10 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { journalpostId, saksnummer2, "\"journalfoerendeEnhet\":\"4806\"", - "\"bruker\":{\"id\":\"${endreJournalpostCommand.gjelder}\",\"idType\":\"FNR\"}" + "\"bruker\":{\"id\":\"${endreJournalpostCommand.gjelder}\",\"idType\":\"FNR\"}", ) }, - { stubs.verifyStub.oppgaveOppdaterKalt(0) } + { stubs.verifyStub.oppgaveOppdaterKalt(0) }, ) } @@ -281,7 +281,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { @DisplayName("skal endre journalført journalpost med flere saker") @Throws( IOException::class, - JSONException::class + JSONException::class, ) fun skalEndreJournalfortJournalpostMedFlereSaker() { val existingSaksnummer = Stubs.SAKSNUMMER_JOURNALPOST @@ -292,12 +292,12 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { .copy( skalJournalfores = false, dokumentDato = LocalDate.of(2020, 2, 3), - tilknyttSaker = listOf(existingSaksnummer, newSaksnummer) + tilknyttSaker = listOf(existingSaksnummer, newSaksnummer), ) stubs.mockSafResponseHentJournalpost( "journalpostJournalfortSafResponse.json", - HttpStatus.OK + HttpStatus.OK, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -310,7 +310,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostIdFraJson, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headerMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -326,22 +326,22 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { journalpostIdFraJson, "\"avsenderMottaker\":{\"navn\":\"Dauden, Svarte\"}", "\"datoMottatt\":\"2020-02-03\"", - "\"dokumenter\":[{\"dokumentInfoId\":\"1\",\"tittel\":\"In a galazy far far away\",\"brevkode\":\"BLABLA\"}]" + "\"dokumenter\":[{\"dokumentInfoId\":\"1\",\"tittel\":\"In a galazy far far away\",\"brevkode\":\"BLABLA\"}]", ) }, { stubs.verifyStub.dokarkivTilknyttSakerKalt( journalpostIdFraJson, newSaksnummer, - "\"journalfoerendeEnhet\":\"4806\"" + "\"journalfoerendeEnhet\":\"4806\"", ) }, { stubs.verifyStub.dokarkivTilknyttSakerIkkeKalt( journalpostIdFraJson, - existingSaksnummer + existingSaksnummer, ) - } + }, ) } @@ -361,7 +361,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headerMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -375,7 +375,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { { stubs.verifyStub.dokarkivOppdaterKalt(journalpostId, "") }, { stubs.verifyStub.dokarkivFerdigstillIkkeKalt(journalpostId) }, { stubs.verifyStub.oppgaveOpprettIkkeKalt() }, - { stubs.verifyStub.oppgaveSokIkkeKalt() } + { stubs.verifyStub.oppgaveSokIkkeKalt() }, ) } @@ -396,9 +396,9 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { EndreReturDetaljer( RETUR_DETALJER_DATO_2, LocalDate.parse("2021-10-10"), - "Ny beskrivelse 2" - ) - ) + "Ny beskrivelse 2", + ), + ), ) val safResponse = opprettUtgaendeSafResponseWithReturDetaljer() safResponse.antallRetur = 1 @@ -414,7 +414,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journal/JOARK-" + journalpostIdFraJson, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headersMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -431,9 +431,9 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { "tilleggsopplysninger\":" + "[{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + "{\"nokkel\":\"retur0_2021-08-20\",\"verdi\":\"Ny beskrivelse 1\"}," + - "{\"nokkel\":\"retur0_2021-10-10\",\"verdi\":\"Ny beskrivelse 2\"}]" + "{\"nokkel\":\"retur0_2021-10-10\",\"verdi\":\"Ny beskrivelse 2\"}]", ) - } + }, ) } @@ -450,22 +450,22 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-10-02"), - true - ) + true, + ), ) val safResponse = opprettUtgaendeSafResponse( journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ) safResponse.antallRetur = 1 stubs.mockSafResponseHentJournalpost(safResponse) @@ -484,16 +484,16 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { EndreReturDetaljer( null, LocalDate.parse("2021-12-15"), - "Ny returdetalj" - ) - ) + "Ny returdetalj", + ), + ), ) // when val oppdaterJournalpostResponseEntity = httpHeaderTestRestTemplate.exchange( initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headersMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -511,9 +511,9 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { "{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + "{\"nokkel\":\"Lretur0_2020-01-02\",\"verdi\":\"En god begrunnelse for hvorfor dokument kom i retur\"}," + "{\"nokkel\":\"Lretur0_2020-10-02\",\"verdi\":\"En annen god begrunnelse for hvorfor dokument kom i retur\"}," + - "{\"nokkel\":\"retur0_2021-12-15\",\"verdi\":\"Ny returdetalj\"}]" + "{\"nokkel\":\"retur0_2021-12-15\",\"verdi\":\"Ny returdetalj\"}]", ) - } + }, ) } @@ -530,22 +530,22 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-10-02"), - true - ) + true, + ), ) val safResponse = opprettUtgaendeSafResponse( journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ) safResponse.antallRetur = 1 stubs.mockSafResponseHentJournalpost(safResponse) @@ -564,16 +564,16 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { EndreReturDetaljer( LocalDate.parse("2020-10-02"), LocalDate.parse("2021-12-15"), - "Oppdatert returdetalj" - ) - ) + "Oppdatert returdetalj", + ), + ), ) // when val oppdaterJournalpostResponseEntity = httpHeaderTestRestTemplate.exchange( initUrl() + "/journal/JOARK-" + journalpostId, HttpMethod.PATCH, HttpEntity(endreJournalpostCommand, headersMedEnhet), - JournalpostDto::class.java + JournalpostDto::class.java, ) // then @@ -589,7 +589,7 @@ class EndreJournalpostControllerTest : AbstractControllerTest() { .extracting { it.headers[HttpHeaders.WARNING] } .`as`("Feilmelding") .isEqualTo(listOf("Ugyldige data: Kan ikke endre låste returdetaljer, Kan ikke endre returdetaljer opprettet før dokumentdato")) - } + }, ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostControllerTest.kt index fa4c9bff..806002b4 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/JournalpostControllerTest.kt @@ -57,7 +57,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { stubs.mockSafResponseHentJournalpost(journalpostSafNotFoundResponse, HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) val journalpostResponseEntity = httpHeaderTestRestTemplate.getForEntity( - initUrl() + "/journal/JOARK-1?saksnummer=007" + initUrl() + "/journal/JOARK-1?saksnummer=007", ) Assertions.assertThat(journalpostResponseEntity).satisfies( { @@ -72,9 +72,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { Assertions.assertThat(it.statusCode).`as`("status") .isEqualTo(HttpStatus.NOT_FOUND) }, - { stubs.verifyStub.harEnSafKallEtterHentJournalpost() } + { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, ) - } + }, ) } @@ -92,9 +92,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { org.junit.jupiter.api.Assertions.assertAll( { Assertions.assertThat(it.statusCode).isEqualTo(HttpStatus.NOT_FOUND) }, { Assertions.assertThat(it.body).isNull() }, - { stubs.verifyStub.harEnSafKallEtterHentJournalpost() } + { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, ) - } + }, ) } @@ -107,7 +107,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse( PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), - HttpStatus.BAD_REQUEST + HttpStatus.BAD_REQUEST, ) val responseEntity = httpHeaderTestRestTemplate.getForEntity(initUrl() + "/journal/JOARK-" + journalpostIdFraJson) @@ -120,9 +120,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { }, { Assertions.assertThat(it.body).isNull() }, { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, - { stubs.verifyStub.bidragPersonKalt() } + { stubs.verifyStub.bidragPersonKalt() }, ) - } + }, ) } @@ -176,8 +176,8 @@ internal class JournalpostControllerTest : AbstractControllerTest() { stubs.mockSafResponseHentJournalpost( opprettSafResponse( journalpostId = journalpostIdFraJson.toString(), - sak = null - ) + sak = null, + ), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -200,8 +200,8 @@ internal class JournalpostControllerTest : AbstractControllerTest() { AvsenderMottakerDto( AVSENDER_NAVN, AVSENDER_ID, - AvsenderMottakerDtoIdType.FNR - ) + AvsenderMottakerDtoIdType.FNR, + ), ) }, { @@ -219,7 +219,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { { Assertions.assertThat(saker).isNotNull.hasSize(0) }, { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, { stubs.verifyStub.harIkkeEnSafKallEtterTilknyttedeJournalposter() }, - { stubs.verifyStub.bidragPersonKalt() } + { stubs.verifyStub.bidragPersonKalt() }, ) }) } @@ -231,7 +231,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { val journalpostIdFraJson = 201028011 stubs.mockSafResponseHentJournalpost( responseJournalpostJsonWithReturDetaljer, - HttpStatus.OK + HttpStatus.OK, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -256,9 +256,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2020-11-15"), "Beskrivelse av retur", - false - ) - ) + false, + ), + ), ).isTrue() }, { @@ -267,9 +267,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2020-12-14"), "Beskrivelse av retur mer tekst for å teste lengre verdier", - false - ) - ) + false, + ), + ), ).isTrue() }, { @@ -278,9 +278,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2022-12-15"), "Beskrivelse av retur 2 mer tekst for å teste lengre verdier", - false - ) - ) + false, + ), + ), ).isTrue() }, { Assertions.assertThat(returDetaljer!!.antall).isEqualTo(3) }, @@ -290,7 +290,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { }, { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, { stubs.verifyStub.harIkkeEnSafKallEtterTilknyttedeJournalposter() }, - { stubs.verifyStub.bidragPersonKalt() } + { stubs.verifyStub.bidragPersonKalt() }, ) }) } @@ -302,7 +302,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { val journalpostIdFraJson = 201028011 stubs.mockSafResponseHentJournalpost( "journalpostSafLockedReturDetaljerResponse.json", - HttpStatus.OK + HttpStatus.OK, ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -327,9 +327,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2020-11-15"), "Beskrivelse av retur", - true - ) - ) + true, + ), + ), ).isTrue() }, { @@ -338,9 +338,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2020-12-14"), "Beskrivelse av retur mer tekst for å teste lengre verdier", - true - ) - ) + true, + ), + ), ).isTrue() }, { @@ -349,9 +349,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2022-12-15"), "Beskrivelse av retur 2 mer tekst for å teste lengre verdier", - true - ) - ) + true, + ), + ), ).isTrue() }, { @@ -360,9 +360,9 @@ internal class JournalpostControllerTest : AbstractControllerTest() { ReturDetaljerLog( LocalDate.parse("2022-12-20"), "Beskrivelse av retur uten lås", - false - ) - ) + false, + ), + ), ).isTrue() }, { Assertions.assertThat(returDetaljer!!.antall).isEqualTo(4) }, @@ -372,7 +372,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { }, { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, { stubs.verifyStub.harIkkeEnSafKallEtterTilknyttedeJournalposter() }, - { stubs.verifyStub.bidragPersonKalt() } + { stubs.verifyStub.bidragPersonKalt() }, ) }) } @@ -417,7 +417,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { }, { stubs.verifyStub.harEnSafKallEtterHentJournalpost() }, { stubs.verifyStub.harEnSafKallEtterTilknyttedeJournalposter() }, - { stubs.verifyStub.bidragPersonKalt() } + { stubs.verifyStub.bidragPersonKalt() }, ) }) } @@ -436,8 +436,8 @@ internal class JournalpostControllerTest : AbstractControllerTest() { journalstatus = JournalStatus.JOURNALFOERT, tilleggsopplysninger = tilleggsOpplysninger, sak = Sak("5276661"), - avsenderMottaker = AvsenderMottaker(navn = "Samhandler navn") - ) + avsenderMottaker = AvsenderMottaker(navn = "Samhandler navn"), + ), ) stubs.mockSafResponseTilknyttedeJournalposter(HttpStatus.OK) stubs.mockPersonResponse(PersonDto(PERSON_IDENT, aktørId = AKTOR_IDENT), HttpStatus.OK) @@ -466,7 +466,7 @@ internal class JournalpostControllerTest : AbstractControllerTest() { }, { Assertions.assertThat(jouralposterResponseEntity.body).hasSize(3) }, { stubs.verifyStub.bidragPersonKalt() }, - { stubs.verifyStub.harSafEnKallEtterDokumentOversiktFagsak() } + { stubs.verifyStub.harSafEnKallEtterDokumentOversiktFagsak() }, ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostControllerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostControllerTest.kt index 6c417e2d..8a7573b4 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostControllerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/controller/OpprettJournalpostControllerTest.kt @@ -40,14 +40,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = false, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -72,7 +72,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"SW5uaG9sZCBww6UgZG9rdW1lbnRldA==\"}]}," + "{\"tittel\":\"$TITTEL_VEDLEGG1\"," + "\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"SW5uaG9sZCBww6UgZG9rdW1lbnRldCB2ZWRsZWdn\"}]}]," + - "\"avsenderMottaker\":{\"id\":\"$GJELDER_ID\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"id\":\"$GJELDER_ID\",\"idType\":\"FNR\"}}", ) } } @@ -86,13 +86,13 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { skalFerdigstilles = true, journalposttype = JournalpostType.UTGÅENDE, tilknyttSaker = listOf(saksnummer1, saksnummer2), - journalførendeEnhet = "4806" + journalførendeEnhet = "4806", ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockSafResponseHentJournalpost(journalpost) @@ -101,14 +101,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = true, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -123,7 +123,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"tittel\":\"$TITTEL_HOVEDDOKUMENT\"", "\"journalfoerendeEnhet\":\"4806\"", "\"journalpostType\":\"UTGAAENDE\"", - "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}", ) stubs.verifyStub.dokarkivTilknyttSakerKalt(1, nyJpId) stubs.verifyStub.dokarkivTilknyttSakerKalt(nyJpId, saksnummer2) @@ -144,19 +144,19 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { dokumenter = listOf( OpprettDokumentDto( tittel = TITTEL_HOVEDDOKUMENT, - dokumentreferanse = "DOKREF1" + dokumentreferanse = "DOKREF1", ), OpprettDokumentDto( tittel = TITTEL_VEDLEGG1, - dokumentreferanse = "DOKREF2" - ) - ) + dokumentreferanse = "DOKREF2", + ), + ), ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockBidragDokumentHentDokumentResponse("DOKREF1", "DOK1".toByteArray()) stubs.mockBidragDokumentHentDokumentResponse("DOKREF2", "DOK2".toByteArray()) @@ -166,14 +166,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = true, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -190,10 +190,10 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"journalpostType\":\"UTGAAENDE\"", "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}", "\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"${ - Base64.getEncoder().encodeToString("DOK1".toByteArray()) + Base64.getEncoder().encodeToString("DOK1".toByteArray()) }\"}]},{\"tittel\":\"Tittel på vedlegg\",\"dokumentvarianter\":[{\"filtype\":\"PDFA\",\"variantformat\":\"ARKIV\",\"fysiskDokument\":\"${ - Base64.getEncoder().encodeToString("DOK2".toByteArray()) - }\"}]}]" + Base64.getEncoder().encodeToString("DOK2".toByteArray()) + }\"}]}]", ) stubs.verifyStub.dokarkivTilknyttSakerKalt(1, nyJpId) stubs.verifyStub.dokarkivTilknyttSakerKalt(nyJpId, saksnummer2) @@ -213,13 +213,13 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { journalposttype = JournalpostType.UTGÅENDE, tilknyttSaker = listOf(saksnummer1, saksnummer2), journalførendeEnhet = "4806", - tittel = "Journalpost tittel" + tittel = "Journalpost tittel", ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockSafResponseHentJournalpost(journalpost) @@ -228,14 +228,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = true, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -250,7 +250,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"tittel\":\"Journalpost tittel\"", "\"journalfoerendeEnhet\":\"4806\"", "\"journalpostType\":\"UTGAAENDE\"", - "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}", ) stubs.verifyStub.dokarkivTilknyttSakerKalt(1, nyJpId) stubs.verifyStub.dokarkivTilknyttSakerKalt(nyJpId, saksnummer2) @@ -268,17 +268,17 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { avsenderMottaker = AvsenderMottakerDto( ident = samhandlerId, navn = "Samhandler navnesen", - type = AvsenderMottakerDtoIdType.SAMHANDLER + type = AvsenderMottakerDtoIdType.SAMHANDLER, ), journalposttype = JournalpostType.UTGÅENDE, tilknyttSaker = listOf(saksnummer1), - journalførendeEnhet = "4806" + journalførendeEnhet = "4806", ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockSafResponseHentJournalpost(journalpost) @@ -287,14 +287,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = true, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -310,7 +310,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"journalfoerendeEnhet\":\"4806\"", "\"journalpostType\":\"UTGAAENDE\"", "\"avsenderMottaker\":{\"navn\":\"Samhandler navnesen\"}", - "\"tilleggsopplysninger\":[{\"nokkel\":\"samhandlerId\",\"verdi\":\"$samhandlerId\"}]" + "\"tilleggsopplysninger\":[{\"nokkel\":\"samhandlerId\",\"verdi\":\"$samhandlerId\"}]", ) stubs.verifyStub.dokarkivOppdaterKalt(nyJpId, "aud-localhost") } @@ -325,13 +325,13 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { journalposttype = JournalpostType.UTGÅENDE, tilknyttSaker = listOf(saksnummer1), journalførendeEnhet = "4806", - kanal = MottakUtsendingKanal.INGEN_DISTRIBUSJON + kanal = MottakUtsendingKanal.INGEN_DISTRIBUSJON, ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockSafResponseHentJournalpost(journalpost) @@ -340,14 +340,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = true, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -363,7 +363,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"journalfoerendeEnhet\":\"4806\"", "\"journalpostType\":\"UTGAAENDE\"", "\"kanal\":\"INGEN_DISTRIBUSJON\"", - "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}" + "\"avsenderMottaker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}}", ) stubs.verifyStub.dokarkivOppdaterKalt(nyJpId, "aud-localhost") } @@ -379,13 +379,13 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { journalposttype = JournalpostType.NOTAT, tilknyttSaker = listOf(saksnummer1, saksnummer2), datoDokument = LocalDateTime.parse("2022-01-05T10:52:03"), - journalførendeEnhet = "4806" + journalførendeEnhet = "4806", ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockSafResponseHentJournalpost(journalpost) stubs.mockDokarkivOppdaterRequest(nyJpId) @@ -393,14 +393,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = true, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -415,7 +415,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "\"tittel\":\"Tittel på hoveddokument\"", "\"datoDokument\":\"2022-01-05T10:52:03\"", "\"journalpostType\":\"NOTAT\"", - "\"bruker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}" + "\"bruker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}", ) stubs.verifyStub.dokarkivOpprettKaltNotContains(true, "avsenderMottaker") stubs.verifyStub.dokarkivTilknyttSakerKalt(1, nyJpId) @@ -434,13 +434,13 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { journalposttype = JournalpostType.NOTAT, tilknyttSaker = listOf(saksnummer1, saksnummer2), journalførendeEnhet = "4806", - saksbehandlerIdent = "Z9494124" + saksbehandlerIdent = "Z9494124", ) val nyJpId = 123123123L val journalpost = opprettSafResponse(nyJpId.toString()).copy( - sak = Sak(saksnummer1) + sak = Sak(saksnummer1), ) stubs.mockBidragOrganisasjonSaksbehandler(navn = "Hansen, Hans") stubs.mockSafResponseHentJournalpost(journalpost) @@ -450,14 +450,14 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { stubs.mockDokarkivOpprettRequest( nyJpId, ferdigstill = false, - dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") } + dokumentList = request.dokumenter.map { DokumentInfo("DOK_ID_${it.tittel}") }, ) val response = httpHeaderTestRestTemplate.exchange( initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.OK @@ -471,7 +471,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "{\"sak\":{\"fagsakId\":\"132213\",\"fagsaksystem\":\"BISYS\",\"sakstype\":\"FAGSAK\"}", "\"tittel\":\"Tittel på hoveddokument\"", "\"journalpostType\":\"NOTAT\"", - "\"bruker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}" + "\"bruker\":{\"id\":\"12345678910\",\"idType\":\"FNR\"}", ) stubs.verifyStub.dokarkivFerdigstillKalt( 1, @@ -479,7 +479,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { "{\"journalfoerendeEnhet\":\"4806\"," + "\"journalfortAvNavn\":\"Hansen, Hans\"," + "\"opprettetAvNavn\":\"Hansen, Hans\"," + - "\"datoJournal\":null}" + "\"datoJournal\":null}", ) stubs.verifyStub.dokarkivOpprettKaltNotContains(false, "avsenderMottaker") stubs.verifyStub.dokarkivTilknyttSakerKalt(1, nyJpId) @@ -531,7 +531,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { val nyJpId = 123123123L stubs.mockDokarkivOpprettRequest( nyJpId, - ferdigstill = false + ferdigstill = false, ) val header = HttpHeaders() @@ -541,7 +541,7 @@ internal class OpprettJournalpostControllerTest : AbstractControllerTest() { initUrl() + "/journalpost", HttpMethod.POST, HttpEntity(request, header), - OpprettJournalpostResponse::class.java + OpprettJournalpostResponse::class.java, ) response.statusCode shouldBe HttpStatus.BAD_REQUEST diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/EndreJournalpostValidationTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/EndreJournalpostValidationTest.kt index e6d1be7f..341f8e46 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/EndreJournalpostValidationTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/EndreJournalpostValidationTest.kt @@ -21,20 +21,20 @@ internal class EndreJournalpostValidationTest { relevanteDatoer = listOf( DatoType( "2021-08-18T13:20:33", - "DATO_DOKUMENT" - ) - ) + "DATO_DOKUMENT", + ), + ), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() .copy( skalJournalfores = false, - endreReturDetaljer = emptyList() + endreReturDetaljer = emptyList(), ) Assertions.assertDoesNotThrow { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } } @@ -45,20 +45,20 @@ internal class EndreJournalpostValidationTest { relevanteDatoer = listOf( DatoType( "2021-08-18T13:20:33", - "DATO_DOKUMENT" - ) - ) + "DATO_DOKUMENT", + ), + ), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() .copy( skalJournalfores = false, - endreReturDetaljer = emptyList() + endreReturDetaljer = emptyList(), ) Assertions.assertDoesNotThrow { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } } @@ -70,30 +70,30 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2023-10-02") - ) + LocalDate.parse("2023-10-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand().copy( skalJournalfores = false, endreReturDetaljer = - listOf(EndreReturDetaljer(null, LocalDate.parse("2022-01-15"), "Ny beskrivelse 1")) + listOf(EndreReturDetaljer(null, LocalDate.parse("2022-01-15"), "Ny beskrivelse 1")), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).isEqualTo("Ugyldige data: Kan ikke opprette ny returdetalj (originalDato=null)") @@ -107,18 +107,18 @@ internal class EndreJournalpostValidationTest { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2023-10-02") - ) + LocalDate.parse("2023-10-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2019-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2019-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() @@ -128,16 +128,16 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( LocalDate.parse("2020-01-02"), LocalDate.parse("2022-01-15"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).isEqualTo("Ugyldige data: Kan ikke endre låste returdetaljer") @@ -150,18 +150,18 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2021-09-02") - ) + LocalDate.parse("2021-09-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 0 val endreJournalpostCommand = createEndreJournalpostCommand() @@ -171,15 +171,15 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( LocalDate.parse("2021-09-02"), LocalDate.parse("2022-01-15"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).isEqualTo("Ugyldige data: Kan ikke endre returdetaljer på journalpost som ikke har kommet i retur") @@ -192,18 +192,18 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-10-02") - ) + LocalDate.parse("2020-10-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() @@ -213,15 +213,15 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( null, LocalDate.parse("2020-11-15"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).contains("Kan ikke opprette ny returdetalj med returdato før dokumentdato") @@ -236,23 +236,23 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - endreDato - ) + endreDato, + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( DatoType( LocalDateTime.of(dokumentDato, LocalTime.of(0, 0)).toString(), - "DATO_DOKUMENT" - ) - ) + "DATO_DOKUMENT", + ), + ), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() @@ -262,15 +262,15 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( endreDato, LocalDate.now().plusDays(1), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).isEqualTo("Ugyldige data: Kan ikke oppdatere returdato til etter dagens dato") @@ -285,23 +285,23 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - endreDato - ) + endreDato, + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( DatoType( LocalDateTime.of(dokumentDato, LocalTime.of(0, 0)).toString(), - "DATO_DOKUMENT" - ) - ) + "DATO_DOKUMENT", + ), + ), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() @@ -311,15 +311,15 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( endreDato, LocalDate.parse("2021-02-02"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).isEqualTo("Ugyldige data: Kan ikke endre returdetaljer opprettet før dokumentdato") @@ -335,35 +335,35 @@ internal class EndreJournalpostValidationTest { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", endreDato, - true - ) + true, + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( DatoType( LocalDateTime.of(dokumentDato, LocalTime.of(0, 0)).toString(), - "DATO_DOKUMENT" - ) - ) + "DATO_DOKUMENT", + ), + ), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand().copy( skalJournalfores = false, - endreReturDetaljer = listOf(EndreReturDetaljer(null, endreDato, "Ny beskrivelse 1")) + endreReturDetaljer = listOf(EndreReturDetaljer(null, endreDato, "Ny beskrivelse 1")), ) val throwable = Assertions.assertThrows(ViolationException::class.java) { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } assertThat(throwable.message).isEqualTo("Ugyldige data: Kan ikke endre låste returdetaljer") @@ -377,34 +377,34 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-02-02") - ) + LocalDate.parse("2020-02-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( DatoType( LocalDateTime.of(dokumentDato, LocalTime.of(0, 0)).toString(), - "DATO_DOKUMENT" - ) - ) + "DATO_DOKUMENT", + ), + ), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand().copy( skalJournalfores = false, - endreReturDetaljer = listOf(EndreReturDetaljer(null, dokumentDato, "Ny beskrivelse 1")) + endreReturDetaljer = listOf(EndreReturDetaljer(null, dokumentDato, "Ny beskrivelse 1")), ) Assertions.assertDoesNotThrow { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } } @@ -416,18 +416,18 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-10-02") - ) + LocalDate.parse("2020-10-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand().copy( @@ -436,15 +436,15 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( null, LocalDate.parse("2022-01-15"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) Assertions.assertDoesNotThrow { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } } @@ -456,18 +456,18 @@ internal class EndreJournalpostValidationTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2021-10-15") - ) + LocalDate.parse("2021-10-15"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand().copy( @@ -476,15 +476,15 @@ internal class EndreJournalpostValidationTest { EndreReturDetaljer( LocalDate.parse("2021-10-15"), LocalDate.parse("2021-11-15"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) Assertions.assertDoesNotThrow { EndreJournalpostCommandIntern( endreJournalpostCommand, - "0000" + "0000", ).sjekkGyldigEndring(journalpost) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JoarkOpprettJournalpostValidatorTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JoarkOpprettJournalpostValidatorTest.kt index 4645b4b0..a4cbaa5a 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JoarkOpprettJournalpostValidatorTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JoarkOpprettJournalpostValidatorTest.kt @@ -29,7 +29,9 @@ class JoarkOpprettJournalpostValidatorTest { val request = createJoarkOpprettJournalpostRequest().copy(avsenderMottaker = null) val result = shouldThrow { validerKanOppretteJournalpost(request) } - val request2 = createJoarkOpprettJournalpostRequest().copy(avsenderMottaker = JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker()) + val request2 = createJoarkOpprettJournalpostRequest().copy( + avsenderMottaker = JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker(), + ) val result2 = shouldThrow { validerKanOppretteJournalpost(request2) } result.message shouldBe "Journalpost må ha satt avsender/mottaker" @@ -52,11 +54,11 @@ class JoarkOpprettJournalpostValidatorTest { tittel = "", dokumentvarianter = listOf( JoarkOpprettJournalpostRequest.DokumentVariant( - fysiskDokument = "Innhold på dokumentet".toByteArray() - ) - ) - ) - ) + fysiskDokument = "Innhold på dokumentet".toByteArray(), + ), + ), + ), + ), ) val result = shouldThrow { validerKanOppretteJournalpost(request) } @@ -65,7 +67,9 @@ class JoarkOpprettJournalpostValidatorTest { @Test fun `Validering skal feile hvis fysiskDokument ikke er satt på dokument`() { - val request = createJoarkOpprettJournalpostRequest().copy(dokumenter = listOf(JoarkOpprettJournalpostRequest.Dokument(tittel = TITTEL_HOVEDDOKUMENT))) + val request = createJoarkOpprettJournalpostRequest().copy( + dokumenter = listOf(JoarkOpprettJournalpostRequest.Dokument(tittel = TITTEL_HOVEDDOKUMENT)), + ) val result = shouldThrow { validerKanOppretteJournalpost(request) } result.message shouldBe "Dokument \"Tittel på hoveddokument\" må minst ha en dokumentvariant" diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JournalpostTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JournalpostTest.kt index 584871f5..41c2c0c0 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JournalpostTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/JournalpostTest.kt @@ -41,14 +41,17 @@ internal class JournalpostTest { @DisplayName("skal mappe en journalpost fra json") @Throws(IOException::class) fun skalMappeJournalpostFraJson() { - val (avsenderMottaker, bruker, dokumenter, journalforendeEnhet, journalfortAvNavn, journalpostId, journalposttype, _, journalstatus, relevanteDatoer, _, tema, _, tittel) = objectMapper.readValue( + val ( + avsenderMottaker, bruker, dokumenter, journalforendeEnhet, journalfortAvNavn, journalpostId, + journalposttype, _, journalstatus, relevanteDatoer, _, tema, _, tittel, + ) = objectMapper.readValue( journalpostJsonText, - Journalpost::class.java + Journalpost::class.java, ) org.junit.jupiter.api.Assertions.assertAll( Executable { assertThat( - avsenderMottaker + avsenderMottaker, ).`as`("avsenderMottaker").isEqualTo(AvsenderMottaker("Tuborg", null, null)) }, Executable { @@ -58,8 +61,8 @@ internal class JournalpostTest { assertThat(dokumenter).`as`("dokumenter").isEqualTo( java.util.List.of( Dokument("ROD SNO", "12345", "BI01S02"), - Dokument("SNOMANNEN", "56789", "BI01S02") - ) + Dokument("SNOMANNEN", "56789", "BI01S02"), + ), ) }, Executable { @@ -82,12 +85,12 @@ internal class JournalpostTest { java.util.List.of( DatoType("2010-12-16T00:00", "DATO_JOURNALFOERT"), DatoType("2010-12-15T00:00", "DATO_REGISTRERT"), - DatoType("2020-12-15T01:00", "DATO_AVS_RETUR") - ) + DatoType("2020-12-15T01:00", "DATO_AVS_RETUR"), + ), ) }, Executable { assertThat(tema).`as`("tema").isEqualTo("AAP") }, - Executable { assertThat(tittel).`as`("tittel").isEqualTo("...and so on...") } + Executable { assertThat(tittel).`as`("tittel").isEqualTo("...and so on...") }, ) } @@ -123,38 +126,38 @@ internal class JournalpostTest { assertThat( getReturDetaljerDOByDate( returDetaljer, - "2020-12-14" - ) + "2020-12-14", + ), ).isNotNull() }, Executable { assertThat( getReturDetaljerDOByDate( returDetaljer, - "2020-12-14" - ).beskrivelse + "2020-12-14", + ).beskrivelse, ).isEqualTo( - "Beskrivelse av retur mer tekst for å teste lengre verdier" + "Beskrivelse av retur mer tekst for å teste lengre verdier", ) }, Executable { assertThat( getReturDetaljerDOByDate( returDetaljer, - "2020-12-15" - ).beskrivelse + "2020-12-15", + ).beskrivelse, ).isEqualTo( - "Beskrivelse av retur 2 mer tekst for å teste lengre verdier" + "Beskrivelse av retur 2 mer tekst for å teste lengre verdier", ) }, Executable { assertThat( getReturDetaljerDOByDate( returDetaljer, - "2020-11-15" - ).beskrivelse + "2020-11-15", + ).beskrivelse, ).isEqualTo("Beskrivelse av retur") - } + }, ) } @@ -173,7 +176,7 @@ internal class JournalpostTest { Executable { assertThat(adresse!!.postnummer).isEqualTo("7950") }, Executable { assertThat(adresse!!.poststed).isEqualTo("ABELVÆR") }, Executable { assertThat(adresse!!.land).isEqualTo("NO") }, - Executable { assertThat(journalpost.hentJournalStatus()).isEqualTo(JournalpostStatus.KLAR_FOR_DISTRIBUSJON) } + Executable { assertThat(journalpost.hentJournalStatus()).isEqualTo(JournalpostStatus.KLAR_FOR_DISTRIBUSJON) }, ) } @@ -187,7 +190,7 @@ internal class JournalpostTest { journalpost.tilleggsopplysninger.setDistribusjonBestillt() org.junit.jupiter.api.Assertions.assertAll( Executable { assertThat(journalpost.hentJournalStatus()).isEqualTo(JournalpostStatus.RESERVERT) }, - Executable { assertThat(journalpost.hentJournalpostType()).isEqualTo("X") } + Executable { assertThat(journalpost.hentJournalpostType()).isEqualTo("X") }, ) } @@ -200,7 +203,7 @@ internal class JournalpostTest { journalpost.journalposttype = JournalpostType.U journalpost.tilleggsopplysninger.setDistribusjonBestillt() org.junit.jupiter.api.Assertions.assertAll( - Executable { assertThat(journalpost.hentJournalStatus()).isEqualTo(JournalpostStatus.EKSPEDERT) } + Executable { assertThat(journalpost.hentJournalStatus()).isEqualTo(JournalpostStatus.EKSPEDERT) }, ) } @@ -263,7 +266,7 @@ internal class JournalpostTest { @Test fun `Skal ikke hente avvik FARSKAP UTELUKKET hvis tema FAR og status mottatt`() { val journalpost = Journalpost( - dokumenter = listOf(Dokument("Test tittel")) + dokumenter = listOf(Dokument("Test tittel")), ) journalpost.journalstatus = JournalStatus.MOTTATT journalpost.journalposttype = JournalpostType.I @@ -276,7 +279,7 @@ internal class JournalpostTest { @Test fun `Skal ikke hente avvik FARSKAP UTELUKKET hvis tema FAR men har tittel med prefiks FARSKAP UTELUKKET`() { val journalpost = Journalpost( - dokumenter = listOf(Dokument("$FARSKAP_UTELUKKET_PREFIKS: Test tittel")) + dokumenter = listOf(Dokument("$FARSKAP_UTELUKKET_PREFIKS: Test tittel")), ) journalpost.journalstatus = JournalStatus.MOTTATT journalpost.journalposttype = JournalpostType.U @@ -395,10 +398,14 @@ internal class JournalpostTest { assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse).isEqualTo("Returpost") assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.dato).isEqualTo(RETUR_DETALJER_DATO_1) - assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse, + ).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") assertThat(journalpostDto.returDetaljer?.logg?.get(2)?.dato).isEqualTo(RETUR_DETALJER_DATO_2) - assertThat(journalpostDto.returDetaljer?.logg?.get(2)?.beskrivelse).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(2)?.beskrivelse, + ).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") } @Test @@ -409,7 +416,7 @@ internal class JournalpostTest { journalpost.antallRetur = 1 journalpost.relevanteDatoer = listOf( DatoType("2023-08-18T13:20:33", "DATO_DOKUMENT"), - DatoType(returDato.toString(), "DATO_AVS_RETUR") + DatoType(returDato.toString(), "DATO_AVS_RETUR"), ) val journalpostDto = journalpost.tilJournalpostDto() assertThat(journalpostDto.returDetaljer?.antall).isEqualTo(3) @@ -420,10 +427,14 @@ internal class JournalpostTest { assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse).isEqualTo("Returpost") assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.dato).isEqualTo(RETUR_DETALJER_DATO_1) - assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse, + ).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") assertThat(journalpostDto.returDetaljer?.logg?.get(2)?.dato).isEqualTo(RETUR_DETALJER_DATO_2) - assertThat(journalpostDto.returDetaljer?.logg?.get(2)?.beskrivelse).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(2)?.beskrivelse, + ).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") } @Test @@ -435,15 +446,15 @@ internal class JournalpostTest { ReturDetaljerLogDO( "1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", RETUR_DETALJER_DATO_2, - true - ) + true, + ), ) tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", sistRetur, - true - ) + true, + ), ) tilleggsopplysninger.setDistribusjonBestillt() journalpost.tilleggsopplysninger = tilleggsopplysninger @@ -452,8 +463,8 @@ internal class JournalpostTest { journalpost.relevanteDatoer = listOf( DatoType( LocalDateTime.of(sistRetur, LocalTime.of(1, 1)).toString(), - "DATO_DOKUMENT" - ) + "DATO_DOKUMENT", + ), ) val journalpostDto = journalpost.tilJournalpostDto() assertThat(journalpostDto.returDetaljer?.antall).isEqualTo(3) @@ -464,10 +475,14 @@ internal class JournalpostTest { assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse).isEqualTo("Returpost") assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.dato).isEqualTo(RETUR_DETALJER_DATO_2) - assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse, + ).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") assertThat(journalpostDto.returDetaljer?.logg?.get(2)?.dato).isEqualTo(sistRetur) - assertThat(journalpostDto.returDetaljer?.logg?.get(2)?.beskrivelse).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(2)?.beskrivelse, + ).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") } @Test @@ -478,14 +493,14 @@ internal class JournalpostTest { tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", - LocalDate.parse("2022-10-22") - ) + LocalDate.parse("2022-10-22"), + ), ) tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", - sistRetur - ) + sistRetur, + ), ) tilleggsopplysninger.setDistribusjonBestillt() journalpost.tilleggsopplysninger = tilleggsopplysninger @@ -494,8 +509,8 @@ internal class JournalpostTest { journalpost.relevanteDatoer = listOf( DatoType( LocalDateTime.of(sistRetur, LocalTime.of(1, 1)).toString(), - "DATO_DOKUMENT" - ) + "DATO_DOKUMENT", + ), ) val journalpostDto = journalpost.tilJournalpostDto() assertThat(journalpostDto.returDetaljer?.antall).isEqualTo(2) @@ -503,10 +518,14 @@ internal class JournalpostTest { assertThat(journalpostDto.returDetaljer?.dato).isEqualTo(sistRetur) assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.dato).isEqualTo(LocalDate.parse("2022-10-22")) - assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse, + ).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.dato).isEqualTo(sistRetur) - assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse, + ).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") } @Test @@ -518,14 +537,14 @@ internal class JournalpostTest { tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", - LocalDate.parse("2022-10-22") - ) + LocalDate.parse("2022-10-22"), + ), ) tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", - sistRetur - ) + sistRetur, + ), ) tilleggsopplysninger.setDistribusjonBestillt() journalpost.tilleggsopplysninger = tilleggsopplysninger @@ -538,10 +557,14 @@ internal class JournalpostTest { assertThat(journalpostDto.returDetaljer?.dato).isEqualTo(sistRetur) assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.dato).isEqualTo(LocalDate.parse("2022-10-22")) - assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse, + ).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.dato).isEqualTo(sistRetur) - assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse, + ).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") } @Test @@ -557,10 +580,14 @@ internal class JournalpostTest { assertThat(journalpostDto.returDetaljer?.dato).isNull() assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.dato).isEqualTo(RETUR_DETALJER_DATO_1) - assertThat(journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(0)?.beskrivelse, + ).isEqualTo("1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.dato).isEqualTo(sistRetur) - assertThat(journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") + assertThat( + journalpostDto.returDetaljer?.logg?.get(1)?.beskrivelse, + ).isEqualTo("2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier") } @Test @@ -570,15 +597,15 @@ internal class JournalpostTest { ReturDetaljerLogDO( "1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", RETUR_DETALJER_DATO_1, - false - ) + false, + ), ) tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", RETUR_DETALJER_DATO_2, - false - ) + false, + ), ) tilleggsopplysninger.setDistribusjonBestillt() tilleggsopplysninger.lockAllReturDetaljerLog() @@ -594,8 +621,8 @@ internal class JournalpostTest { val journalpost = opprettUtgaendeSafResponse() .copy( utsendingsinfo = UtsendingsInfo( - fysiskpostSendt = FysiskpostSendt("Adresselinje1\n3022 Drammen\nNO") - ) + fysiskpostSendt = FysiskpostSendt("Adresselinje1\n3022 Drammen\nNO"), + ), ) val distribuertTilAdresse = journalpost.distribuertTilAdresse() distribuertTilAdresse?.adresselinje1 shouldBe "Adresselinje1" @@ -609,8 +636,8 @@ internal class JournalpostTest { val journalpost = opprettUtgaendeSafResponse() .copy( utsendingsinfo = UtsendingsInfo( - fysiskpostSendt = FysiskpostSendt("Adresselinje1\nAdresselinje2\nAdresselinje3\n3022 Drammen\nNO") - ) + fysiskpostSendt = FysiskpostSendt("Adresselinje1\nAdresselinje2\nAdresselinje3\n3022 Drammen\nNO"), + ), ) val distribuertTilAdresse = journalpost.distribuertTilAdresse() distribuertTilAdresse?.adresselinje1 shouldBe "Adresselinje1" @@ -626,8 +653,8 @@ internal class JournalpostTest { val journalpost = opprettUtgaendeSafResponse() .copy( utsendingsinfo = UtsendingsInfo( - fysiskpostSendt = FysiskpostSendt("Adresselinje1\nAdresselinje2\nAdresselinje3\nCalifornia\nUSA") - ) + fysiskpostSendt = FysiskpostSendt("Adresselinje1\nAdresselinje2\nAdresselinje3\nCalifornia\nUSA"), + ), ) val distribuertTilAdresse = journalpost.distribuertTilAdresse() distribuertTilAdresse?.adresselinje1 shouldBe "Adresselinje1" @@ -638,14 +665,11 @@ internal class JournalpostTest { distribuertTilAdresse?.land shouldBe "USA" } - private fun getReturDetaljerDOByDate( - returDetaljerLogDOList: List, - dato: String - ): ReturDetaljerLogDO { + private fun getReturDetaljerDOByDate(returDetaljerLogDOList: List, dato: String): ReturDetaljerLogDO { return returDetaljerLogDOList.stream() .filter { (_, dato1): ReturDetaljerLogDO -> dato1 == LocalDate.parse(dato) }.findFirst() .orElse( - ReturDetaljerLogDO("junit", LocalDate.now()) + ReturDetaljerLogDO("junit", LocalDate.now()), ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/LagreJournalpostTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/LagreJournalpostTest.kt index 24874e5e..e69bdc31 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/LagreJournalpostTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/LagreJournalpostTest.kt @@ -18,60 +18,60 @@ internal class LagreJournalpostTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-10-02") - ) + LocalDate.parse("2020-10-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand() .copy( skalJournalfores = false, endreReturDetaljer = - listOf(EndreReturDetaljer(null, LocalDate.parse("2022-11-15"), "Ny beskrivelse 1")) + listOf(EndreReturDetaljer(null, LocalDate.parse("2022-11-15"), "Ny beskrivelse 1")), ) val lagreJournalpost = LagreJournalpostRequest( journalpost = journalpost, endreJournalpostCommand = EndreJournalpostCommandIntern(endreJournalpostCommand, ""), - journalpostId = 213 + journalpostId = 213, ) assertThat(lagreJournalpost.tilleggsopplysninger?.size).isEqualTo(4) assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2022-11-15" + "2022-11-15", ) } - } + }, ).isTrue assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2020-01-02" + "2020-01-02", ) } - } + }, ).isTrue assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2020-10-02" + "2020-10-02", ) } - } + }, ).isTrue } @@ -81,58 +81,58 @@ internal class LagreJournalpostTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-10-02") - ) + LocalDate.parse("2020-10-02"), + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 0 val endreJournalpostCommand = createEndreJournalpostCommand().copy( skalJournalfores = false, endreReturDetaljer = - listOf(EndreReturDetaljer(null, LocalDate.parse("2022-11-15"), "Ny beskrivelse 1")) + listOf(EndreReturDetaljer(null, LocalDate.parse("2022-11-15"), "Ny beskrivelse 1")), ) val lagreJournalpost = LagreJournalpostRequest( journalpost = journalpost, endreJournalpostCommand = EndreJournalpostCommandIntern(endreJournalpostCommand, ""), - journalpostId = 213 + journalpostId = 213, ) assertThat(lagreJournalpost.tilleggsopplysninger?.size).isEqualTo(2) assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2022-11-15" + "2022-11-15", ) } - } + }, ).isFalse assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2020-01-02" + "2020-01-02", ) } - } + }, ).isTrue assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2020-10-02" + "2020-10-02", ) } - } + }, ).isTrue } @@ -144,18 +144,18 @@ internal class LagreJournalpostTest { tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", - LocalDate.parse("2020-01-02") - ) + LocalDate.parse("2020-01-02"), + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", - datoSomSkalEndres - ) + datoSomSkalEndres, + ), ) val journalpost = opprettUtgaendeSafResponse( tilleggsopplysninger = tilleggsOpplysninger, - relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")) + relevanteDatoer = listOf(DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT")), ) journalpost.antallRetur = 1 val endreJournalpostCommand = createEndreJournalpostCommand().copy( @@ -164,52 +164,52 @@ internal class LagreJournalpostTest { EndreReturDetaljer( datoSomSkalEndres, LocalDate.parse("2022-11-15"), - "Ny beskrivelse 1" - ) - ) + "Ny beskrivelse 1", + ), + ), ) val lagreJournalpost = LagreJournalpostRequest( journalpost = journalpost, endreJournalpostCommand = EndreJournalpostCommandIntern(endreJournalpostCommand, ""), - journalpostId = 213 + journalpostId = 213, ) assertThat(lagreJournalpost.tilleggsopplysninger?.size).isEqualTo(3) assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2022-11-15" + "2022-11-15", ) } - } + }, ).isTrue assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - datoSomSkalEndres.toString() + datoSomSkalEndres.toString(), ) } - } + }, ).isFalse assertThat( lagreJournalpost.tilleggsopplysninger?.filter { it.values.any { value -> value.contains( - "2022-11-15" + "2022-11-15", ) } - }?.joinToString() + }?.joinToString(), ).contains("Ny beskrivelse 1") assertThat( lagreJournalpost.tilleggsopplysninger?.any { it.values.any { value -> value.contains( - "2020-01-02" + "2020-01-02", ) } - } + }, ).isTrue } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostValidatorTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostValidatorTest.kt index 231edf38..b3bd59ec 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostValidatorTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/dto/OpprettJournalpostValidatorTest.kt @@ -63,9 +63,9 @@ class OpprettJournalpostValidatorTest { dokumenter = listOf( OpprettDokumentDto( tittel = "", - fysiskDokument = "Innhold på dokumentet vedlegg".toByteArray() - ) - ) + fysiskDokument = "Innhold på dokumentet vedlegg".toByteArray(), + ), + ), ) val result = shouldThrow { validerKanOppretteJournalpost(request) } @@ -78,7 +78,7 @@ class OpprettJournalpostValidatorTest { val request = createOpprettJournalpostRequest().copy( skalFerdigstilles = true, tilknyttSaker = listOf(""), - tema = "BID" + tema = "BID", ) val result = shouldThrow { validerKanOppretteJournalpost(request) } @@ -91,7 +91,7 @@ class OpprettJournalpostValidatorTest { val request = createOpprettJournalpostRequest().copy( skalFerdigstilles = true, journalførendeEnhet = "4214", - tema = "BID" + tema = "BID", ) val result = shouldThrow { validerKanOppretteJournalpost(request) } @@ -102,13 +102,16 @@ class OpprettJournalpostValidatorTest { @Test fun `Validering skal feile hvis avsendernavn er lengre enn 128 tegn`() { val requestValid = createOpprettJournalpostRequest().copy( - avsenderMottaker = AvsenderMottakerDto("Navn mindre enn 128 tegn") + avsenderMottaker = AvsenderMottakerDto("Navn mindre enn 128 tegn"), ) shouldNotThrow { validerKanOppretteJournalpost(requestValid) } val request = createOpprettJournalpostRequest().copy( - avsenderMottaker = AvsenderMottakerDto("Navn lengre enn 128 tegn asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd") + avsenderMottaker = AvsenderMottakerDto( + "Navn lengre enn 128 tegn " + + "asdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasdasd", + ), ) val result = shouldThrow { validerKanOppretteJournalpost(request) } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/BaseKafkaHendelseTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/BaseKafkaHendelseTest.kt index 0455992c..49fe518d 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/BaseKafkaHendelseTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/BaseKafkaHendelseTest.kt @@ -39,7 +39,7 @@ import java.time.Duration @EmbeddedKafka( partitions = 1, brokerProperties = ["listeners=PLAINTEXT://localhost:9092", "port=9092"], - topics = ["topic_joark", "topic_journalpost", "oppgave-hendelse"] + topics = ["topic_joark", "topic_journalpost", "oppgave-hendelse"], ) abstract class BaseKafkaHendelseTest { private val LOGGER = LoggerFactory.getLogger(BaseKafkaHendelseTest::class.java) diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JoarkHendelseTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JoarkHendelseTest.kt index f1f64edd..abae47c8 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JoarkHendelseTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JoarkHendelseTest.kt @@ -46,7 +46,9 @@ import org.springframework.http.HttpStatus import org.springframework.kafka.core.KafkaTemplate import org.springframework.test.context.ActiveProfiles -@ActiveProfiles(value = [BidragDokumentArkivConfig.PROFILE_KAFKA_TEST, BidragDokumentArkivConfig.PROFILE_TEST, BidragDokumentArkivTest.PROFILE_INTEGRATION]) +@ActiveProfiles( + value = [BidragDokumentArkivConfig.PROFILE_KAFKA_TEST, BidragDokumentArkivConfig.PROFILE_TEST, BidragDokumentArkivTest.PROFILE_INTEGRATION], +) @SpringBootTest(classes = [BidragDokumentArkivTest::class]) @AutoConfigureWireMock(port = 0) @EnableMockOAuth2Server @@ -83,8 +85,8 @@ class JoarkHendelseTest { journalstatus = JournalStatus.MOTTATT, journalforendeEnhet = null, bruker = Bruker(BRUKER_AKTOER_ID, BRUKER_TYPE_AKTOERID), - sak = null - ) + sak = null, + ), ) val record = createHendelseRecord(journalpostId) @@ -94,7 +96,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq(expectedJoarkJournalpostId), - jsonCaptor.capture() + jsonCaptor.capture(), ) val journalpostHendelse = objectMapper.readValue(jsonCaptor.value, JournalpostHendelse::class.java) @@ -134,7 +136,7 @@ class JoarkHendelseTest { assertThat(journalpostHendelse).extracting(JournalpostHendelse::journalstatus) .isEqualTo("M") }, - { stubs.verifyStub.harIkkeEnSafKallEtterTilknyttedeJournalposter() } + { stubs.verifyStub.harIkkeEnSafKallEtterTilknyttedeJournalposter() }, ) } @@ -160,20 +162,20 @@ class JoarkHendelseTest { sak = Sak(sak1), relevanteDatoer = listOf( no.nav.bidrag.dokument.arkiv.stubs.DATO_DOKUMENT, - no.nav.bidrag.dokument.arkiv.stubs.DATO_JOURNALFORT + no.nav.bidrag.dokument.arkiv.stubs.DATO_JOURNALFORT, ), tilleggsopplysninger = tilleggsOpplysninger, - journalfortAvNavn = journalfortAvNavn - ) + journalfortAvNavn = journalfortAvNavn, + ), ) stubs.mockSafResponseTilknyttedeJournalposter( listOf( TilknyttetJournalpost( tilknyttetJournalpostId, journalstatus = JournalStatus.JOURNALFOERT, - sak = Sak(sak2) - ) - ) + sak = Sak(sak2), + ), + ), ) val record = createHendelseRecord(journalpostId) @@ -185,7 +187,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq(expectedJoarkJournalpostId), - jsonCaptor.capture() + jsonCaptor.capture(), ) val journalpostHendelse = objectMapper.readValue(jsonCaptor.value, JournalpostHendelse::class.java) @@ -219,7 +221,7 @@ class JoarkHendelseTest { { assertThat(journalpostHendelse.sporing?.brukerident).isEqualTo(journalfortAvIdent) }, { assertThat(journalpostHendelse.sporing?.saksbehandlersNavn).isEqualTo( - journalfortAvNavn + journalfortAvNavn, ) }, { assertThat(journalpostHendelse.sporing?.enhetsnummer).isEqualTo(jfEnhet) }, @@ -233,7 +235,7 @@ class JoarkHendelseTest { assertThat(journalpostHendelse).extracting(JournalpostHendelse::journalstatus) .isEqualTo("J") }, - { stubs.verifyStub.harEnSafKallEtterTilknyttedeJournalposter() } + { stubs.verifyStub.harEnSafKallEtterTilknyttedeJournalposter() }, ) } @@ -248,8 +250,8 @@ class JoarkHendelseTest { journalpostId = journalpostId.toString(), bruker = null, journalstatus = JournalStatus.MOTTATT, - journalforendeEnhet = BRUKER_ENHET - ) + journalforendeEnhet = BRUKER_ENHET, + ), ) stubs.mockSafResponseTilknyttedeJournalposter(listOf()) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -263,7 +265,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq(expectedJoarkJournalpostId), - jsonCaptor.capture() + jsonCaptor.capture(), ) val journalpostHendelse = objectMapper.readValue(jsonCaptor.value, JournalpostHendelse::class.java) @@ -286,7 +288,7 @@ class JoarkHendelseTest { { assertThat(journalpostHendelse).extracting(JournalpostHendelse::journalstatus) .isEqualTo("M") - } + }, ) } @@ -301,8 +303,8 @@ class JoarkHendelseTest { journalpostId = journalpostId.toString(), bruker = Bruker(BRUKER_FNR, BrukerType.FNR.name), journalstatus = JournalStatus.MOTTATT, - journalforendeEnhet = BRUKER_ENHET - ) + journalforendeEnhet = BRUKER_ENHET, + ), ) stubs.mockSafResponseTilknyttedeJournalposter(listOf()) stubs.mockDokarkivOppdaterRequest(journalpostId) @@ -316,7 +318,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq(expectedJoarkJournalpostId), - jsonCaptor.capture() + jsonCaptor.capture(), ) val journalpostHendelse = objectMapper.readValue(jsonCaptor.value, JournalpostHendelse::class.java) @@ -340,7 +342,7 @@ class JoarkHendelseTest { assertThat(journalpostHendelse).extracting(JournalpostHendelse::journalstatus) .isEqualTo("M") }, - { stubs.verifyStub.bidragPersonIkkeKalt() } + { stubs.verifyStub.bidragPersonIkkeKalt() }, ) } @@ -353,14 +355,14 @@ class JoarkHendelseTest { opprettSafResponse( journalpostId = journalpostId.toString(), journalstatus = JournalStatus.MOTTATT, - journalforendeEnhet = BRUKER_ENHET - ) + journalforendeEnhet = BRUKER_ENHET, + ), ) stubs.mockSafResponseTilknyttedeJournalposter(listOf()) stubs.mockBidragOrganisasjonSaksbehandler() stubs.mockPersonResponse( PersonDto(PersonIdent("123"), aktørId = AktørId("12321")), - HttpStatus.OK + HttpStatus.OK, ) val record = createHendelseRecord(journalpostId) @@ -370,7 +372,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock).send( ArgumentMatchers.eq(topicJournalpost), ArgumentMatchers.eq(expectedJoarkJournalpostId), - jsonCaptor.capture() + jsonCaptor.capture(), ) val journalpostHendelse = objectMapper.readValue(jsonCaptor.value, JournalpostHendelse::class.java) @@ -393,7 +395,7 @@ class JoarkHendelseTest { assertThat(journalpostHendelse).extracting(JournalpostHendelse::journalstatus) .isEqualTo("M") }, - { stubs.verifyStub.dokarkivOppdaterIkkeKalt(journalpostId) } + { stubs.verifyStub.dokarkivOppdaterIkkeKalt(journalpostId) }, ) } @@ -410,7 +412,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock, Mockito.never()).send( ArgumentMatchers.any(), ArgumentMatchers.any(), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } @@ -426,7 +428,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock, Mockito.never()).send( ArgumentMatchers.any(), ArgumentMatchers.any(), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } @@ -436,16 +438,16 @@ class JoarkHendelseTest { stubs.mockSts() stubs.mockPersonResponse( PersonDto(PersonIdent("123"), aktørId = AktørId("12321")), - HttpStatus.OK + HttpStatus.OK, ) stubs.mockSafResponseTilknyttedeJournalposter( listOf( TilknyttetJournalpost( 123123L, JournalStatus.FERDIGSTILT, - Sak("5276661") - ) - ) + Sak("5276661"), + ), + ), ) stubs.mockSafResponseHentJournalpost( opprettSafResponse( @@ -456,10 +458,10 @@ class JoarkHendelseTest { Dokument( dokumentInfoId = DOKUMENT_1_ID, brevkode = "CRM_MELDINGSKJEDE", - tittel = DOKUMENT_1_TITTEL - ) - ) - ) + tittel = DOKUMENT_1_TITTEL, + ), + ), + ), ) val record = createHendelseRecord(journalpostId) @@ -469,7 +471,7 @@ class JoarkHendelseTest { verify(kafkaTemplateMock, Mockito.never()).send( ArgumentMatchers.any(), ArgumentMatchers.any(), - ArgumentMatchers.any() + ArgumentMatchers.any(), ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JournalpostKafkaEventProducerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JournalpostKafkaEventProducerTest.kt index 2b3b1859..03eff4d5 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JournalpostKafkaEventProducerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/JournalpostKafkaEventProducerTest.kt @@ -32,8 +32,8 @@ internal class JournalpostKafkaEventProducerTest : BaseKafkaHendelseTest() { opprettSafResponse( journalpostId = journalpostId.toString(), journalstatus = JournalStatus.MOTTATT, - journalforendeEnhet = BRUKER_ENHET - ) + journalforendeEnhet = BRUKER_ENHET, + ), ) stubs.mockDokarkivOppdaterRequest(journalpostId) stubs.mockBidragOrganisasjonSaksbehandler() @@ -74,9 +74,9 @@ internal class JournalpostKafkaEventProducerTest : BaseKafkaHendelseTest() { sak = Sak(sak1), relevanteDatoer = listOf(DATO_DOKUMENT, DATO_JOURNALFORT), tilleggsopplysninger = tilleggsOpplysninger, - journalfortAvNavn = journalfortAvNavn + journalfortAvNavn = journalfortAvNavn, - ) + ), ) stubs.mockDokarkivOppdaterRequest(journalpostId) stubs.mockBidragOrganisasjonSaksbehandler() diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/OppgaveHendelseListenerTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/OppgaveHendelseListenerTest.kt index b43d316e..f173daa0 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/OppgaveHendelseListenerTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/hendelser/OppgaveHendelseListenerTest.kt @@ -36,7 +36,9 @@ import org.springframework.test.context.ActiveProfiles import java.time.LocalDate import java.time.LocalDateTime -@ActiveProfiles(value = [BidragDokumentArkivConfig.PROFILE_KAFKA_TEST, BidragDokumentArkivConfig.PROFILE_TEST, BidragDokumentArkivTest.PROFILE_INTEGRATION]) +@ActiveProfiles( + value = [BidragDokumentArkivConfig.PROFILE_KAFKA_TEST, BidragDokumentArkivConfig.PROFILE_TEST, BidragDokumentArkivTest.PROFILE_INTEGRATION], +) @SpringBootTest(classes = [BidragDokumentArkivTest::class]) @AutoConfigureWireMock(port = 0) @EnableMockOAuth2Server @@ -71,22 +73,22 @@ class OppgaveHendelseListenerTest { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-10-02"), - true - ) + true, + ), ) val safResponse = opprettUtgaendeSafResponse( journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ).copy(utsendingsinfo = UtsendingsInfo(fysiskpostSendt = FysiskpostSendt("Adresselinje1\n3033 Drammen\nNO"))) safResponse.antallRetur = 1 @@ -102,7 +104,7 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) @@ -114,10 +116,10 @@ class OppgaveHendelseListenerTest { "[{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + "{\"nokkel\":\"Lretur0_2020-01-02\",\"verdi\":\"En god begrunnelse for hvorfor dokument kom i retur\"}," + "{\"nokkel\":\"Lretur0_2020-10-02\",\"verdi\":\"En annen god begrunnelse for hvorfor dokument kom i retur\"}," + - "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Returpost\"}]" + "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Returpost\"}]", ) }, - { stubs.verifyStub.oppgaveOppdaterKalt(1, safResponse.hentSaksnummer()) } + { stubs.verifyStub.oppgaveOppdaterKalt(1, safResponse.hentSaksnummer()) }, ) } @@ -134,8 +136,8 @@ class OppgaveHendelseListenerTest { journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsopplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ) safResponse.antallRetur = 1 @@ -152,7 +154,7 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) @@ -174,22 +176,22 @@ class OppgaveHendelseListenerTest { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-10-02"), - true - ) + true, + ), ) val safResponse = opprettUtgaendeSafResponse( journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ).copy(utsendingsinfo = UtsendingsInfo(fysiskpostSendt = FysiskpostSendt("Adresselinje1\n3033 Drammen\nNO"))) safResponse.antallRetur = 1 @@ -207,7 +209,7 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) @@ -219,10 +221,10 @@ class OppgaveHendelseListenerTest { "[{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + "{\"nokkel\":\"Lretur0_2020-01-02\",\"verdi\":\"En god begrunnelse for hvorfor dokument kom i retur\"}," + "{\"nokkel\":\"Lretur0_2020-10-02\",\"verdi\":\"En annen god begrunnelse for hvorfor dokument kom i retur\"}," + - "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Returpost\"}]" + "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Returpost\"}]", ) }, - { stubs.verifyStub.oppgaveOpprettIkkeKalt() } + { stubs.verifyStub.oppgaveOpprettIkkeKalt() }, ) } @@ -237,8 +239,8 @@ class OppgaveHendelseListenerTest { journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ).copy(utsendingsinfo = UtsendingsInfo(fysiskpostSendt = FysiskpostSendt("Adresselinje1\n3033 Drammen\nNO"))) safResponse.antallRetur = 1 @@ -256,7 +258,7 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) @@ -267,9 +269,9 @@ class OppgaveHendelseListenerTest { journalpostId, "\"tilleggsopplysninger\":" + "[{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + - "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Returpost\"}]" + "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Returpost\"}]", ) - } + }, ) } @@ -284,22 +286,22 @@ class OppgaveHendelseListenerTest { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2021-08-20"), - false - ) + false, + ), ) val safResponse = opprettUtgaendeSafResponse( journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ) safResponse.antallRetur = 1 @@ -315,14 +317,14 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) Assertions.assertAll( { stubs.verifyStub.dokarkivOppdaterIkkeKalt(journalpostId) - } + }, ) } @@ -340,8 +342,8 @@ class OppgaveHendelseListenerTest { journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsopplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ) safResponse.antallRetur = 1 @@ -358,7 +360,7 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) @@ -368,13 +370,13 @@ class OppgaveHendelseListenerTest { 1, safResponse.hentSaksnummer(), "\"versjon\":22", - "Mottaker har ikke åpnet forsendelsen via www.nav.no innen 40 timer. Ingen postadresse er registrert. Vurder om mottaker har adresse forsendelsen kan sendes til" + "Mottaker har ikke åpnet forsendelsen via www.nav.no innen 40 timer. Ingen postadresse er registrert. Vurder om mottaker har adresse forsendelsen kan sendes til", ) stubs.verifyStub.dokarkivOppdaterKalt( journalpostId, "\"tilleggsopplysninger\":" + "[{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"},{\"nokkel\":\"origDistDigitalt\",\"verdi\":\"true\"}," + - "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Distribusjon feilet, mottaker mangler postadresse\"}]" + "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"Distribusjon feilet, mottaker mangler postadresse\"}]", ) } } @@ -390,22 +392,22 @@ class OppgaveHendelseListenerTest { ReturDetaljerLogDO( "En god begrunnelse for hvorfor dokument kom i retur", LocalDate.parse("2020-01-02"), - true - ) + true, + ), ) tilleggsOpplysninger.addReturDetaljLog( ReturDetaljerLogDO( "En annen god begrunnelse for hvorfor dokument kom i retur", LocalDate.now(), - true - ) + true, + ), ) val safResponse = opprettUtgaendeSafResponse( journalpostId = journalpostId.toString(), tilleggsopplysninger = tilleggsOpplysninger, relevanteDatoer = listOf( - DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT") - ) + DatoType("2021-08-18T13:20:33", "DATO_DOKUMENT"), + ), ) safResponse.antallRetur = 1 @@ -420,7 +422,7 @@ class OppgaveHendelseListenerTest { 0, 0L, "key", - objectMapper.writeValueAsString(oppgaveData.toHendelse()) + objectMapper.writeValueAsString(oppgaveData.toHendelse()), ) hendelseListener.lesOppgaveOpprettetHendelse(consumerRecord) @@ -431,9 +433,9 @@ class OppgaveHendelseListenerTest { "\"tilleggsopplysninger\":" + "[{\"nokkel\":\"distribusjonBestilt\",\"verdi\":\"true\"}," + "{\"nokkel\":\"Lretur0_2020-01-02\",\"verdi\":\"En god begrunnelse for hvorfor dokument kom i retur\"}," + - "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"En annen god begrunnelse for hvorfor dokument kom i retur\"}" + "{\"nokkel\":\"retur0_${DateUtils.formatDate(LocalDate.now())}\",\"verdi\":\"En annen god begrunnelse for hvorfor dokument kom i retur\"}", ) - } + }, ) } @@ -449,7 +451,7 @@ class OppgaveHendelseListenerTest { aktoerId: String = BRUKER_AKTOER_ID, beskrivelse: String? = null, tilordnetRessurs: String? = null, - saksref: String = "123213123" + saksref: String = "123213123", ) = OppgaveData( id = id, versjon = versjon, @@ -464,12 +466,10 @@ class OppgaveHendelseListenerTest { tilordnetRessurs = tilordnetRessurs, beskrivelse = beskrivelse, aktoerId = aktoerId, - saksreferanse = saksref + saksreferanse = saksref, ) - fun OppgaveData.toHendelse( - type: OppgaveKafkaHendelse.Hendelse.Hendelsestype? = null - ) = OppgaveKafkaHendelse( + fun OppgaveData.toHendelse(type: OppgaveKafkaHendelse.Hendelse.Hendelsestype? = null) = OppgaveKafkaHendelse( hendelse = OppgaveKafkaHendelse.Hendelse( type ?: when (status) { OppgaveStatus.FERDIGSTILT -> OppgaveKafkaHendelse.Hendelse.Hendelsestype.OPPGAVE_FERDIGSTILT @@ -478,7 +478,7 @@ class OppgaveHendelseListenerTest { OppgaveStatus.FEILREGISTRERT -> OppgaveKafkaHendelse.Hendelse.Hendelsestype.OPPGAVE_FEILREGISTRERT else -> OppgaveKafkaHendelse.Hendelse.Hendelsestype.OPPGAVE_ENDRET }, - LocalDateTime.now() + LocalDateTime.now(), ), utfortAv = OppgaveKafkaHendelse.UtfortAv(tilordnetRessurs, tildeltEnhetsnr), oppgave = OppgaveKafkaHendelse.Oppgave( @@ -486,12 +486,12 @@ class OppgaveHendelseListenerTest { 1, kategorisering = OppgaveKafkaHendelse.Kategorisering( tema ?: "BID", - oppgavetype = oppgavetype ?: "JFR" + oppgavetype = oppgavetype ?: "JFR", ), bruker = OppgaveKafkaHendelse.Bruker( aktoerId, - OppgaveKafkaHendelse.Bruker.IdentType.FOLKEREGISTERIDENT - ) - ) + OppgaveKafkaHendelse.Bruker.IdentType.FOLKEREGISTERIDENT, + ), + ), ) } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostServiceTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostServiceTest.kt index 51e72b30..f5f72255 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostServiceTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/service/DistribuerJournalpostServiceTest.kt @@ -40,7 +40,7 @@ class DistribuerJournalpostServiceTest { val exceptionResult = Assertions.assertThrows( IllegalArgumentException::class.java, { validerKanDistribueres(jp) }, - "skal feile hvis journalpost allerede er distribuert" + "skal feile hvis journalpost allerede er distribuert", ) org.assertj.core.api.Assertions.assertThat(exceptionResult.message) .contains("Journalpost er allerede distribuert") @@ -54,7 +54,7 @@ class DistribuerJournalpostServiceTest { val exceptionResult = Assertions.assertThrows( IllegalArgumentException::class.java, { validerKanDistribueres(jp) }, - "skal feile hvis status ikke er FERDIGSTILT" + "skal feile hvis status ikke er FERDIGSTILT", ) org.assertj.core.api.Assertions.assertThat(exceptionResult.message).contains("FERDIGSTILT") } @@ -74,7 +74,7 @@ class DistribuerJournalpostServiceTest { val exceptionResult = Assertions.assertThrows( IllegalArgumentException::class.java, { validerKanDistribueres(jp) }, - "Skal feile hvis mottakerid ikke er satt" + "Skal feile hvis mottakerid ikke er satt", ) org.assertj.core.api.Assertions.assertThat(exceptionResult.message).contains("mottakerId") } @@ -88,7 +88,7 @@ class DistribuerJournalpostServiceTest { val exceptionResult = Assertions.assertThrows( IllegalArgumentException::class.java, { validerKanDistribueres(jp) }, - "Skal feile hvis mottakerid er samhandlerId" + "Skal feile hvis mottakerid er samhandlerId", ) org.assertj.core.api.Assertions.assertThat(exceptionResult.message).contains("samhandlerId") } @@ -102,7 +102,7 @@ class DistribuerJournalpostServiceTest { Assertions.assertThrows( IllegalArgumentException::class.java, { validerAdresse(null) }, - "Skal validere adresse" + "Skal validere adresse", ) } @@ -118,12 +118,12 @@ class DistribuerJournalpostServiceTest { fun skalIkkeValidereNorskAdresseSomManglerPostnummer() { val adresse = createDistribuerTilAdresse() .copy( - postnummer = null + postnummer = null, ) Assertions.assertThrows( IllegalArgumentException::class.java, { validerAdresse(adresse) }, - "Skal ikke validere norsk adresse uten postnummer" + "Skal ikke validere norsk adresse uten postnummer", ) } @@ -132,12 +132,12 @@ class DistribuerJournalpostServiceTest { fun skalIkkeValidereNorskAdresseSomManglerPoststed() { val adresse = createDistribuerTilAdresse() .copy( - poststed = null + poststed = null, ) Assertions.assertThrows( IllegalArgumentException::class.java, { validerAdresse(adresse) }, - "Skal ikke validere norsk adresse uten poststed" + "Skal ikke validere norsk adresse uten poststed", ) } @@ -147,12 +147,12 @@ class DistribuerJournalpostServiceTest { val adresse = createDistribuerTilAdresse() .copy( adresselinje1 = null, - land = "SE" + land = "SE", ) Assertions.assertThrows( IllegalArgumentException::class.java, { validerAdresse(adresse) }, - "Skal ikke validere utenlandsk adresse uten adresselinje1" + "Skal ikke validere utenlandsk adresse uten adresselinje1", ) } @@ -162,12 +162,12 @@ class DistribuerJournalpostServiceTest { val adresse = createDistribuerTilAdresse() .copy( adresselinje1 = null, - land = "SER" + land = "SER", ) Assertions.assertThrows( IllegalArgumentException::class.java, { validerAdresse(adresse) }, - "Skal ikke validere hvis landkode ikke er formatert som alpha-2 kode" + "Skal ikke validere hvis landkode ikke er formatert som alpha-2 kode", ) } @@ -175,7 +175,7 @@ class DistribuerJournalpostServiceTest { fun `skal feile validering hvis adresselinje 1 er lengre enn 128 tegn`() { val adresse = createDistribuerTilAdresse() .copy( - adresselinje1 = "Adresselinje 1 lengre enn 128 tegn asdasdasdasdas sadasd asd asdasd asdasdasdasdasdasdasdasdasdasdasdasdasd asdasdasdasdasdasdasdasdasdasdasdasdasd" + adresselinje1 = "Adresselinje 1 lengre enn 128 tegn asdasdasdasdas sadasd asd asdasd asdasdasdasdasdasdasdasdasdasdasdasdasd asdasdasdasdasdasdasdasdasdasdasdasdasd", ) val result = assertThrows { validerAdresse(adresse) } result.message shouldBe "Adresselinje 1 kan ikke være lengre enn 128 tegn" @@ -185,7 +185,7 @@ class DistribuerJournalpostServiceTest { fun `skal feile validering hvis adresselinje 2 er lengre enn 128 tegn`() { val adresse = createDistribuerTilAdresse() .copy( - adresselinje2 = "Adresselinje 2 lengre enn 128 tegn asdasdasdasdas sadasd asd asdasd asdasdasdasdasdasdasdasdasdasdasdasdasd asdasdasdasdasdasdasdasdasdasdasdasdasd" + adresselinje2 = "Adresselinje 2 lengre enn 128 tegn asdasdasdasdas sadasd asd asdasd asdasdasdasdasdasdasdasdasdasdasdasdasd asdasdasdasdasdasdasdasdasdasdasdasdasd", ) val result = assertThrows { validerAdresse(adresse) } result.message shouldBe "Adresselinje 2 kan ikke være lengre enn 128 tegn" @@ -195,7 +195,7 @@ class DistribuerJournalpostServiceTest { fun `skal feile validering hvis adresselinje 3 er lengre enn 128 tegn`() { val adresse = createDistribuerTilAdresse() .copy( - adresselinje3 = "Adresselinje 3 lengre enn 128 tegn asdasdasdasdas sadasd asd asdasd asdasdasdasdasdasdasdasdasdasdasdasdasd asdasdasdasdasdasdasdasdasdasdasdasdasd" + adresselinje3 = "Adresselinje 3 lengre enn 128 tegn asdasdasdasdas sadasd asd asdasd asdasdasdasdasdasdasdasdasdasdasdasdasd asdasdasdasdasdasdasdasdasdasdasdasdasd", ) val result = assertThrows { validerAdresse(adresse) } result.message shouldBe "Adresselinje 3 kan ikke være lengre enn 128 tegn" diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/service/JournalpostServiceTest.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/service/JournalpostServiceTest.kt index 90bdb843..c88aa362 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/service/JournalpostServiceTest.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/service/JournalpostServiceTest.kt @@ -73,8 +73,8 @@ internal class JournalpostServiceTest { PersonDto( ident = PersonIdent("123123"), navn = FulltNavn(""), - aktørId = AktørId("555555") - ) + aktørId = AktørId("555555"), + ), ) val muligJournalpost = journalpostService!!.get(Discriminator.REGULAR_USER).hentJournalpostMedFnrOgTilknyttedeSaker(journalpostIdFraJson, null) diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/Stubs.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/Stubs.kt index 949a51bb..28a529ea 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/Stubs.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/Stubs.kt @@ -52,31 +52,27 @@ class Stubs { mockDokarkivTilknyttRequest(journalpostId, 123213213L) } - fun mockDokarkivTilknyttRequest( - journalpostId: Long, - nyJournalpostId: Long = 123213213L, - status: HttpStatus = HttpStatus.OK - ) { + fun mockDokarkivTilknyttRequest(journalpostId: Long, nyJournalpostId: Long = 123213213L, status: HttpStatus = HttpStatus.OK) { try { WireMock.stubFor( WireMock.put( WireMock.urlMatching( "/dokarkivknytt" + String.format( DokarkivKnyttTilSakConsumer.URL_KNYTT_TIL_ANNEN_SAK, - journalpostId - ) - ) + journalpostId, + ), + ), ).willReturn( aClosedJsonResponse() .withStatus(status.value()) .withBody( objectMapper.writeValueAsString( KnyttTilAnnenSakResponse( - nyJournalpostId.toString() - ) - ) - ) - ) + nyJournalpostId.toString(), + ), + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -95,11 +91,11 @@ class Stubs { objectMapper.writeValueAsString( GeografiskTilknytningResponse( enhetId!!, - "navn" - ) - ) - ) - ) + "navn", + ), + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -117,11 +113,11 @@ class Stubs { objectMapper.writeValueAsString( SaksbehandlerInfoResponse( ident, - navn - ) - ) - ) - ) + navn, + ), + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -140,16 +136,13 @@ class Stubs { "idToken": "DUMMY", "scope": "openid", "token_type": "Bearer" - }""" - ) - ) + }""", + ), + ), ) } - fun mockBestmDistribusjonskanal( - response: BestemKanalResponse, - status: HttpStatus = HttpStatus.OK - ) { + fun mockBestmDistribusjonskanal(response: BestemKanalResponse, status: HttpStatus = HttpStatus.OK) { try { WireMock.stubFor( WireMock.post(WireMock.urlMatching("/dokdistkanal/rest/bestemDistribusjonskanal")) @@ -158,10 +151,10 @@ class Stubs { .withStatus(status.value()) .withBody( objectMapper.writeValueAsString( - response - ) - ) - ) + response, + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -177,10 +170,10 @@ class Stubs { .withStatus(status.value()) .withBody( objectMapper.writeValueAsString( - DokDistDistribuerJournalpostResponse(bestillingId!!) - ) - ) - ) + DokDistDistribuerJournalpostResponse(bestillingId!!), + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -193,23 +186,20 @@ class Stubs { WireMock.get(WireMock.urlMatching("/saf/rest/hentdokument/.*")).willReturn( aClosedJsonResponse() .withStatus(HttpStatus.OK.value()) - .withBody(DOKUMENT_FIL) - ) + .withBody(DOKUMENT_FIL), + ), ) } @Throws(JsonProcessingException::class) - fun mockBidragDokumentHentDokumentResponse( - dokumentref: String = "(.*)", - response: ByteArray = DOKUMENT_FIL.toByteArray() - ) { + fun mockBidragDokumentHentDokumentResponse(dokumentref: String = "(.*)", response: ByteArray = DOKUMENT_FIL.toByteArray()) { WireMock.stubFor( WireMock.get(WireMock.urlMatching("/dokument/dokumentreferanse/$dokumentref")) .willReturn( aClosedJsonResponse() .withStatus(HttpStatus.OK.value()) - .withBody(response) - ) + .withBody(response), + ), ) } @@ -218,7 +208,7 @@ class Stubs { nyJournalpostId: Long?, status: HttpStatus = HttpStatus.OK, ferdigstill: Boolean = true, - dokumentList: List = emptyList() + dokumentList: List = emptyList(), ) { WireMock.stubFor( WireMock.post(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "?forsoekFerdigstill=$ferdigstill")) @@ -232,11 +222,11 @@ class Stubs { if (ferdigstill) "FERDIGTILT" else "MIDLERTIDIG", null, ferdigstill, - dokumentList - ) - ) - ) - ) + dokumentList, + ), + ), + ), + ), ) } @@ -251,11 +241,11 @@ class Stubs { .withBody( objectMapper.writeValueAsString( OppdaterJournalpostResponse( - journalpostId - ) - ) - ) - ) + journalpostId, + ), + ), + ), + ), ) } @@ -265,13 +255,13 @@ class Stubs { WireMock.urlEqualTo( "/dokarkiv" + String.format( DokarkivConsumer.URL_JOURNALPOSTAPI_V1_FEILREGISTRER, - journalpostId - ) + "/opphevFeilregistrertSakstilknytning" - ) + journalpostId, + ) + "/opphevFeilregistrertSakstilknytning", + ), ).willReturn( aClosedJsonResponse() - .withStatus(HttpStatus.OK.value()) - ) + .withStatus(HttpStatus.OK.value()), + ), ) } @@ -281,13 +271,13 @@ class Stubs { WireMock.urlEqualTo( "/dokarkiv" + String.format( DokarkivConsumer.URL_JOURNALPOSTAPI_V1_FEILREGISTRER, - journalpostId - ) + "/feilregistrerSakstilknytning" - ) + journalpostId, + ) + "/feilregistrerSakstilknytning", + ), ).willReturn( aClosedJsonResponse() - .withStatus(HttpStatus.OK.value()) - ) + .withStatus(HttpStatus.OK.value()), + ), ) } @@ -295,12 +285,12 @@ class Stubs { WireMock.stubFor( WireMock.patch( WireMock.urlMatching( - "/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + journalpostId + "/oppdaterDistribusjonsinfo" - ) + "/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + journalpostId + "/oppdaterDistribusjonsinfo", + ), ).willReturn( aClosedJsonResponse() - .withStatus(HttpStatus.OK.value()) - ) + .withStatus(HttpStatus.OK.value()), + ), ) } @@ -308,12 +298,12 @@ class Stubs { WireMock.stubFor( WireMock.patch( WireMock.urlMatching( - "/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + journalpostId + "/ferdigstill" - ) + "/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + journalpostId + "/ferdigstill", + ), ).willReturn( aClosedJsonResponse() - .withStatus(HttpStatus.OK.value()) - ) + .withStatus(HttpStatus.OK.value()), + ), ) } @@ -333,12 +323,12 @@ class Stubs { .withStatus(HttpStatus.OK.value()) .withBody( "{\"data\":{\"journalpost\": ${ - objectMapper.writeValueAsString( - distribusjonsInfo - ) - } }}" - ) - ) + objectMapper.writeValueAsString( + distribusjonsInfo, + ) + } }}", + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -357,12 +347,12 @@ class Stubs { .withStatus(HttpStatus.OK.value()) .withBody( "{\"data\":{\"journalpost\": ${ - objectMapper.writeValueAsString( - journalpost - ) - } }}" - ) - ) + objectMapper.writeValueAsString( + journalpost, + ) + } }}", + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -370,11 +360,7 @@ class Stubs { } @JvmOverloads - fun mockSafResponseHentJournalpost( - journalpost: Journalpost?, - scenarioState: String? = null, - nextScenario: String? = null - ) { + fun mockSafResponseHentJournalpost(journalpost: Journalpost?, scenarioState: String? = null, nextScenario: String? = null) { try { WireMock.stubFor( WireMock.post(WireMock.urlEqualTo("/saf/graphql")) @@ -387,11 +373,11 @@ class Stubs { .withBody( "{\"data\":{\"journalpost\": %s }}".formatted( objectMapper.writeValueAsString( - journalpost - ) - ) - ) - ).willSetStateTo(nextScenario) + journalpost, + ), + ), + ), + ).willSetStateTo(nextScenario), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -406,8 +392,8 @@ class Stubs { aClosedJsonResponse() .withHeader(HttpHeaders.CONTENT_TYPE, "application/json") .withStatus(status.value()) - .withBodyFile("json/$filename") - ) + .withBodyFile("json/$filename"), + ), ) } @@ -417,8 +403,8 @@ class Stubs { .withRequestBody(ContainsPattern("query tilknyttedeJournalposter")).willReturn( aClosedJsonResponse() .withStatus(httpStatus.value()) - .withBodyFile("json/tilknyttedeJournalposter.json") - ) + .withBodyFile("json/tilknyttedeJournalposter.json"), + ), ) } @@ -432,12 +418,12 @@ class Stubs { .withStatus(HttpStatus.OK.value()) .withBody( "{\"data\":{\"tilknyttedeJournalposter\": ${ - objectMapper.writeValueAsString( - tilknyttetJournalposts - ) - }}}" - ) - ) + objectMapper.writeValueAsString( + tilknyttetJournalposts, + ) + }}}", + ), + ), ) } catch (e: Exception) { Assert.fail(e.message) @@ -455,11 +441,11 @@ class Stubs { .withBody( "{\"data\":{\"dokumentoversiktFagsak\":{\"journalposter\": %s }}}".formatted( objectMapper.writeValueAsString( - response - ) - ) - ) - ) + response, + ), + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -472,8 +458,8 @@ class Stubs { WireMock.get(WireMock.urlMatching("/oppgave/.*")).willReturn( aClosedJsonResponse() .withStatus(HttpStatus.OK.value()) - .withBody(objectMapper.writeValueAsString(OppgaveSokResponse())) - ) + .withBody(objectMapper.writeValueAsString(OppgaveSokResponse())), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -486,8 +472,8 @@ class Stubs { WireMock.get(WireMock.urlMatching("/oppgave/.*")).willReturn( aClosedJsonResponse() .withStatus(status.value()) - .withBody(objectMapper.writeValueAsString(oppgaveSokResponse)) - ) + .withBody(objectMapper.writeValueAsString(oppgaveSokResponse)), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -498,17 +484,12 @@ class Stubs { WireMock.stubFor( WireMock.post(WireMock.urlMatching("/oppgave/.*")).willReturn( aClosedJsonResponse() - .withStatus(status.value()) - ) + .withStatus(status.value()), + ), ) } - fun mockHentOppgave( - oppgaveId: Long, - oppgaveResponse: OppgaveData, - scenarioState: String? = null, - nextScenario: String? = null - ) { + fun mockHentOppgave(oppgaveId: Long, oppgaveResponse: OppgaveData, scenarioState: String? = null, nextScenario: String? = null) { WireMock.stubFor( WireMock.get(WireMock.urlMatching("/oppgave/$oppgaveId")) .inScenario("Oppgave response") @@ -516,24 +497,20 @@ class Stubs { aClosedJsonResponse() .withHeader(HttpHeaders.CONTENT_TYPE, "application/json") .withStatus(HttpStatus.OK.value()) - .withBody(ObjectMapper().writeValueAsString(oppgaveResponse)) - ).willSetStateTo(nextScenario) + .withBody(ObjectMapper().writeValueAsString(oppgaveResponse)), + ).willSetStateTo(nextScenario), ) } - fun mockOppdaterOppgave( - status: HttpStatus, - scenarioState: String? = null, - nextScenario: String? = null - ) { + fun mockOppdaterOppgave(status: HttpStatus, scenarioState: String? = null, nextScenario: String? = null) { WireMock.stubFor( WireMock.patch(WireMock.urlMatching("/oppgave/.*")) .inScenario("Oppdater oppgave") .whenScenarioStateIs(scenarioState ?: Scenario.STARTED).willReturn( aClosedJsonResponse() .withHeader(HttpHeaders.CONTENT_TYPE, "application/json") - .withStatus(status.value()) - ).willSetStateTo(nextScenario) + .withStatus(status.value()), + ).willSetStateTo(nextScenario), ) } @@ -554,11 +531,11 @@ class Stubs { postnummer = Postnummer("3939"), poststed = Poststed("OSLO"), land = Landkode2("NO"), - land3 = Landkode3("NOR") - ) - ) - ) - ) + land3 = Landkode3("NOR"), + ), + ), + ), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -571,8 +548,8 @@ class Stubs { WireMock.post(WireMock.urlMatching("/person/.*")).willReturn( aClosedJsonResponse() .withStatus(status.value()) - .withBody(ObjectMapper().writeValueAsString(personResponse)) - ) + .withBody(ObjectMapper().writeValueAsString(personResponse)), + ), ) } catch (e: JsonProcessingException) { Assert.fail(e.message) @@ -594,10 +571,10 @@ class Stubs { WireMock.urlPathMatching( String.format( "/organisasjon/bidrag-organisasjon/arbeidsfordeling/enhetsliste/geografisktilknytning/%s", - ident ?: ".*" - ) - ) - ) + ident ?: ".*", + ), + ), + ), ) } @@ -606,13 +583,13 @@ class Stubs { WireMock.urlMatching( "/dokarkivknytt" + String.format( DokarkivKnyttTilSakConsumer.URL_KNYTT_TIL_ANNEN_SAK, - journalpostId - ) - ) + journalpostId, + ), + ), ) Arrays.stream(contains).forEach { contain: String? -> verify.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(WireMock.exactly(times), verify) @@ -630,7 +607,7 @@ class Stubs { val requestPattern = WireMock.postRequestedFor(WireMock.urlMatching("/oppgave/.*")) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(requestPattern) @@ -640,7 +617,7 @@ class Stubs { val requestPattern = WireMock.patchRequestedFor(WireMock.urlMatching("/oppgave/.*")) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(count!!, requestPattern) @@ -659,7 +636,7 @@ class Stubs { Arrays.stream(params).forEach { (first, second): Pair -> requestPattern.withQueryParam( first, - ContainsPattern(second) + ContainsPattern(second), ) } WireMock.verify(requestPattern) @@ -667,10 +644,12 @@ class Stubs { fun dokarkivOppdaterDistribusjonsInfoKalt(journalpostId: Long, vararg contains: String?) { val requestPattern = - WireMock.patchRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + '/' + journalpostId + "/oppdaterDistribusjonsinfo")) + WireMock.patchRequestedFor( + WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + '/' + journalpostId + "/oppdaterDistribusjonsinfo"), + ) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(requestPattern) @@ -679,7 +658,7 @@ class Stubs { fun dokarkivOppdaterIkkeKalt(journalpostId: Long) { WireMock.verify( 0, - WireMock.putRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + '/' + journalpostId)) + WireMock.putRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + '/' + journalpostId)), ) } @@ -688,7 +667,7 @@ class Stubs { WireMock.putRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + '/' + journalpostId)) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(0, requestPattern) @@ -699,7 +678,7 @@ class Stubs { WireMock.putRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + '/' + journalpostId)) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(requestPattern) @@ -713,8 +692,8 @@ class Stubs { val requestPattern = WireMock.getRequestedFor( WireMock.urlEqualTo( - "/dokument/dokumentreferanse/$dokumentId" - ) + "/dokument/dokumentreferanse/$dokumentId", + ), ) WireMock.verify(requestPattern) } @@ -726,19 +705,21 @@ class Stubs { String.format( "/saf/rest/hentdokument/%s/%s/ARKIV", journalpostId, - dokumentId - ) - ) + dokumentId, + ), + ), ) WireMock.verify(requestPattern) } fun dokarkivOpprettKalt(ferdigstill: Boolean = true, vararg contains: String?) { val requestPattern = - WireMock.postRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "?forsoekFerdigstill=$ferdigstill")) + WireMock.postRequestedFor( + WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "?forsoekFerdigstill=$ferdigstill"), + ) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(requestPattern) @@ -746,7 +727,9 @@ class Stubs { fun dokarkivOpprettKaltNotContains(ferdigstill: Boolean = true, vararg contains: String?) { val requestPattern = - WireMock.postRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "?forsoekFerdigstill=$ferdigstill")) + WireMock.postRequestedFor( + WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "?forsoekFerdigstill=$ferdigstill"), + ) Arrays.stream(contains) .forEach { requestPattern.withRequestBody(NotContainsPattern(it)) } WireMock.verify(requestPattern) @@ -754,14 +737,14 @@ class Stubs { fun bidragPersonKalt() { WireMock.verify( - WireMock.postRequestedFor(WireMock.urlMatching("/person/.*")) + WireMock.postRequestedFor(WireMock.urlMatching("/person/.*")), ) } fun bidragPersonIkkeKalt() { WireMock.verify( 0, - WireMock.getRequestedFor(WireMock.urlMatching("/person/.*")) + WireMock.getRequestedFor(WireMock.urlMatching("/person/.*")), ) } @@ -770,7 +753,7 @@ class Stubs { WireMock.postRequestedFor(WireMock.urlMatching("/dokdistfordeling/.*")) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(requestPattern) @@ -779,16 +762,18 @@ class Stubs { fun dokdistFordelingIkkeKalt() { WireMock.verify( 0, - WireMock.postRequestedFor(WireMock.urlMatching("/dokdistfordeling/.*")) + WireMock.postRequestedFor(WireMock.urlMatching("/dokdistfordeling/.*")), ) } fun dokarkivFerdigstillKalt(times: Int, journalpostId: Long, vararg contains: String?) { val requestPattern = - WireMock.patchRequestedFor(WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + journalpostId + "/ferdigstill")) + WireMock.patchRequestedFor( + WireMock.urlEqualTo("/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + journalpostId + "/ferdigstill"), + ) Arrays.stream(contains).forEach { contain: String? -> requestPattern.withRequestBody( - ContainsPattern(contain) + ContainsPattern(contain), ) } WireMock.verify(WireMock.exactly(times), requestPattern) @@ -817,10 +802,10 @@ class Stubs { WireMock.urlMatching( "/dokarkiv" + String.format( DokarkivConsumer.URL_JOURNALPOSTAPI_V1_FEILREGISTRER, - journalpostId - ) + "/opphevFeilregistrertSakstilknytning" - ) - ) + journalpostId, + ) + "/opphevFeilregistrertSakstilknytning", + ), + ), ) } @@ -830,10 +815,10 @@ class Stubs { WireMock.urlMatching( "/dokarkiv" + String.format( DokarkivConsumer.URL_JOURNALPOSTAPI_V1_FEILREGISTRER, - journalpostId - ) + "/feilregistrerSakstilknytning" - ) - ) + journalpostId, + ) + "/feilregistrerSakstilknytning", + ), + ), ) } @@ -844,10 +829,10 @@ class Stubs { WireMock.urlMatching( "/dokarkiv" + String.format( DokarkivConsumer.URL_JOURNALPOSTAPI_V1_FEILREGISTRER, - journalpostId - ) + "/feilregistrerSakstilknytning" - ) - ) + journalpostId, + ) + "/feilregistrerSakstilknytning", + ), + ), ) } @@ -857,16 +842,16 @@ class Stubs { WireMock.urlMatching( "/dokarkiv" + DokarkivConsumer.URL_JOURNALPOSTAPI_V1 + "/" + - journalpostId + "/oppdaterDistribusjonsinfo" - ) - ).withRequestBody(ContainsPattern(kanal.name)) + journalpostId + "/oppdaterDistribusjonsinfo", + ), + ).withRequestBody(ContainsPattern(kanal.name)), ) } fun harEnSafKallEtterHentJournalpost() { WireMock.verify( WireMock.postRequestedFor(WireMock.urlEqualTo("/saf/graphql")) - .withRequestBody(ContainsPattern("query journalpost")) + .withRequestBody(ContainsPattern("query journalpost")), ) } @@ -874,14 +859,14 @@ class Stubs { WireMock.verify( antall!!, WireMock.postRequestedFor(WireMock.urlEqualTo("/saf/graphql")) - .withRequestBody(ContainsPattern("query journalpost")) + .withRequestBody(ContainsPattern("query journalpost")), ) } fun harSafEnKallEtterDokumentOversiktFagsak() { WireMock.verify( WireMock.postRequestedFor(WireMock.urlEqualTo("/saf/graphql")) - .withRequestBody(ContainsPattern("query dokumentoversiktFagsak")) + .withRequestBody(ContainsPattern("query dokumentoversiktFagsak")), ) } @@ -897,7 +882,7 @@ class Stubs { WireMock.verify( WireMock.exactly(times), WireMock.postRequestedFor(WireMock.urlEqualTo("/saf/graphql")) - .withRequestBody(ContainsPattern("query tilknyttedeJournalposter")) + .withRequestBody(ContainsPattern("query tilknyttedeJournalposter")), ) } } diff --git a/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/TestData.kt b/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/TestData.kt index 3b9838e1..2b6e449b 100644 --- a/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/TestData.kt +++ b/src/test/java/no/nav/bidrag/dokument/arkiv/stubs/TestData.kt @@ -71,7 +71,7 @@ fun OppgaveHendelse.toOppgaveData(_versjon: Int? = null) = OppgaveData( oppgavetype = oppgavetype, status = status, tema = tema, - saksreferanse = saksreferanse + saksreferanse = saksreferanse, ) @@ -82,13 +82,11 @@ fun createDistribuerTilAdresse(): DistribuerTilAdresse { adresselinje3 = null, land = "NO", postnummer = "3000", - poststed = "Ingen" + poststed = "Ingen", ) } -fun opprettUtgaendeDistribuertSafResponse( - journalpostId: String = JOURNALPOST_ID.toString() -): Journalpost { +fun opprettUtgaendeDistribuertSafResponse(journalpostId: String = JOURNALPOST_ID.toString()): Journalpost { val tilleggsopplysninger = TilleggsOpplysninger() tilleggsopplysninger.setDistribusjonBestillt() return opprettSafResponse( @@ -96,19 +94,17 @@ fun opprettUtgaendeDistribuertSafResponse( tilleggsopplysninger = tilleggsopplysninger, journalpostType = JournalpostType.U, journalstatus = JournalStatus.FERDIGSTILT, - relevanteDatoer = listOf(DATO_DOKUMENT, DATO_RETUR) + relevanteDatoer = listOf(DATO_DOKUMENT, DATO_RETUR), ) } -fun opprettUtgaendeSafResponseWithReturDetaljer( - journalpostId: String = JOURNALPOST_ID.toString() -): Journalpost { +fun opprettUtgaendeSafResponseWithReturDetaljer(journalpostId: String = JOURNALPOST_ID.toString()): Journalpost { return opprettSafResponse( journalpostId = journalpostId, tilleggsopplysninger = createTillegsopplysningerWithReturDetaljer(), journalpostType = JournalpostType.U, journalstatus = JournalStatus.FERDIGSTILT, - relevanteDatoer = listOf(DATO_DOKUMENT, DATO_RETUR) + relevanteDatoer = listOf(DATO_DOKUMENT, DATO_RETUR), ) } @@ -119,10 +115,10 @@ fun opprettUtgaendeSafResponse( Dokument( dokumentInfoId = DOKUMENT_1_ID, tittel = DOKUMENT_1_TITTEL, - brevkode = "BI01A01" - ) + brevkode = "BI01A01", + ), ), - tilleggsopplysninger: TilleggsOpplysninger = TilleggsOpplysninger() + tilleggsopplysninger: TilleggsOpplysninger = TilleggsOpplysninger(), ): Journalpost { return opprettSafResponse( journalpostId = journalpostId, @@ -130,7 +126,7 @@ fun opprettUtgaendeSafResponse( relevanteDatoer = relevanteDatoer, tilleggsopplysninger = tilleggsopplysninger, journalpostType = JournalpostType.U, - journalstatus = JournalStatus.FERDIGSTILT + journalstatus = JournalStatus.FERDIGSTILT, ) } @@ -139,14 +135,14 @@ fun opprettSafResponse( avsenderMottaker: AvsenderMottaker = AvsenderMottaker( AVSENDER_NAVN, AVSENDER_ID, - AvsenderMottakerIdType.FNR + AvsenderMottakerIdType.FNR, ), bruker: Bruker? = Bruker(BRUKER_AKTOER_ID, BRUKER_TYPE_AKTOERID), dokumenter: List = listOf( Dokument( dokumentInfoId = DOKUMENT_1_ID, - tittel = DOKUMENT_1_TITTEL - ) + tittel = DOKUMENT_1_TITTEL, + ), ), tittel: String = DOKUMENT_1_TITTEL, journalforendeEnhet: String? = JOURNALFORENDE_ENHET, @@ -156,7 +152,7 @@ fun opprettSafResponse( tema: String = "BID", sak: Sak? = Sak("5276661"), tilleggsopplysninger: TilleggsOpplysninger = TilleggsOpplysninger(), - journalfortAvNavn: String? = null + journalfortAvNavn: String? = null, ): Journalpost { return Journalpost( kanal = JournalpostKanal.NAV_NO, @@ -172,7 +168,7 @@ fun opprettSafResponse( tittel = tittel, sak = sak, tilleggsopplysninger = tilleggsopplysninger, - journalfortAvNavn = journalfortAvNavn + journalfortAvNavn = journalfortAvNavn, ) } @@ -188,22 +184,22 @@ fun opprettDokumentOversiktfagsakResponse(): List { dokumenter = listOf( Dokument( tittel = DOKUMENT_1_TITTEL, - dokumentInfoId = DOKUMENT_1_ID - ) + dokumentInfoId = DOKUMENT_1_ID, + ), ), journalstatus = JournalStatus.JOURNALFOERT, - tema = "BID" + tema = "BID", ), opprettSafResponse( journalpostId = JOURNALPOST_ID_2.toString(), dokumenter = listOf( Dokument( tittel = DOKUMENT_2_TITTEL, - dokumentInfoId = DOKUMENT_2_ID - ) + dokumentInfoId = DOKUMENT_2_ID, + ), ), journalstatus = JournalStatus.JOURNALFOERT, - tema = "BID" + tema = "BID", ), opprettSafResponse( @@ -211,30 +207,30 @@ fun opprettDokumentOversiktfagsakResponse(): List { dokumenter = listOf( Dokument( tittel = DOKUMENT_3_TITTEL, - dokumentInfoId = DOKUMENT_3_ID - ) + dokumentInfoId = DOKUMENT_3_ID, + ), ), tema = "FAR", - journalstatus = JournalStatus.MOTTATT + journalstatus = JournalStatus.MOTTATT, ), opprettSafResponse( journalpostId = JOURNALPOST_ID_4.toString(), dokumenter = listOf( Dokument( tittel = DOKUMENT_4_TITTEL, - dokumentInfoId = DOKUMENT_4_ID - ) + dokumentInfoId = DOKUMENT_4_ID, + ), ), journalstatus = JournalStatus.FEILREGISTRERT, tema = "BID", - tilleggsopplysninger = tilleggsopplysningerEndretFagomrade + tilleggsopplysninger = tilleggsopplysningerEndretFagomrade, ), opprettUtgaendeSafResponse( journalpostId = JOURNALPOST_ID_5.toString(), - tilleggsopplysninger = tilleggsopplysningerBestiltNyDistribusjon + tilleggsopplysninger = tilleggsopplysningerBestiltNyDistribusjon, - ) + ), ) } @@ -252,14 +248,14 @@ fun createTillegsopplysningerWithReturDetaljer(): TilleggsOpplysninger { tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "1 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", - RETUR_DETALJER_DATO_1 - ) + RETUR_DETALJER_DATO_1, + ), ) tilleggsopplysninger.addReturDetaljLog( ReturDetaljerLogDO( "2 - Beskrivelse av retur med litt lengre test for å teste lengre verdier", - RETUR_DETALJER_DATO_2 - ) + RETUR_DETALJER_DATO_2, + ), ) tilleggsopplysninger.setDistribusjonBestillt() return tilleggsopplysninger @@ -272,8 +268,8 @@ fun createEndreJournalpostCommand(): EndreJournalpostCommand { gjelder = "06127412345", tittel = "So Tired", endreDokumenter = java.util.List.of( - EndreDokument("BLABLA", "1", "In a galazy far far away") - ) + EndreDokument("BLABLA", "1", "In a galazy far far away"), + ), ) return endreJournalpostCommand } @@ -293,28 +289,28 @@ fun createJoarkOpprettJournalpostRequest(): JoarkOpprettJournalpostRequest { tittel = TITTEL_HOVEDDOKUMENT, dokumentvarianter = listOf( JoarkOpprettJournalpostRequest.DokumentVariant( - fysiskDokument = "Innhold på dokumentet".toByteArray() - ) - ) + fysiskDokument = "Innhold på dokumentet".toByteArray(), + ), + ), ), JoarkOpprettJournalpostRequest.Dokument( tittel = TITTEL_VEDLEGG1, dokumentvarianter = listOf( JoarkOpprettJournalpostRequest.DokumentVariant( - fysiskDokument = "Innhold på dokumentet vedlegg".toByteArray() - ) - ) - ) + fysiskDokument = "Innhold på dokumentet vedlegg".toByteArray(), + ), + ), + ), ), journalpostType = JoarkJournalpostType.INNGAAENDE, bruker = JoarkOpprettJournalpostRequest.OpprettJournalpostBruker(GJELDER_ID, idType = null), avsenderMottaker = JoarkOpprettJournalpostRequest.OpprettJournalpostAvsenderMottaker( - GJELDER_ID + GJELDER_ID, ), behandlingstema = BEHANDLINGSTEMA, kanal = Kanal.NAV_NO.name, tema = "BID", - eksternReferanseId = REFID + eksternReferanseId = REFID, ) } @@ -325,18 +321,18 @@ fun createOpprettJournalpostRequest(): OpprettJournalpostRequest { dokumenter = listOf( OpprettDokumentDto( tittel = TITTEL_HOVEDDOKUMENT, - fysiskDokument = "Innhold på dokumentet".toByteArray() + fysiskDokument = "Innhold på dokumentet".toByteArray(), ), OpprettDokumentDto( tittel = TITTEL_VEDLEGG1, - fysiskDokument = "Innhold på dokumentet vedlegg".toByteArray() - ) + fysiskDokument = "Innhold på dokumentet vedlegg".toByteArray(), + ), ), journalposttype = no.nav.bidrag.transport.dokument.JournalpostType.INNGÅENDE, gjelderIdent = GJELDER_ID, avsenderMottaker = AvsenderMottakerDto(ident = GJELDER_ID), behandlingstema = BEHANDLINGSTEMA, kanal = MottakUtsendingKanal.DIGITALT, - referanseId = REFID + referanseId = REFID, ) }