Story/document upload in bestandsdelen

app/gzac/src/main/resources/config/application.yml

@@ -95,6 +95,10 @@ spring:
     messages:
         basename: i18n/messages
     main.allow-bean-definition-overriding: true
+    servlet:
+        multipart:
+            max-file-size: 10MB
+            max-request-size: 10MB
     jersey:
         application-path: /api/camunda-rest
     autoconfigure:
@@ -219,8 +223,9 @@ valtimo:
         acceptedMimeTypes:
             - text/plain
             - application/pdf
-            - image/jpeg
             - application/xml
+            - image/jpeg
+            - image/png
     changelog:
         pbac:
             clear-tables: true

zgw/documenten-api/src/main/kotlin/com/ritense/documentenapi/DocumentenApiPlugin.kt

@@ -20,8 +20,11 @@ import com.fasterxml.jackson.databind.JsonNode
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.kotlin.convertValue
 import com.ritense.documentenapi.DocumentenApiPlugin.Companion.PLUGIN_KEY
+import com.ritense.documentenapi.client.BestandsdelenRequest
 import com.ritense.documentenapi.client.CreateDocumentRequest
+import com.ritense.documentenapi.client.CreateDocumentResult
 import com.ritense.documentenapi.client.DocumentInformatieObject
+import com.ritense.documentenapi.client.DocumentLock
 import com.ritense.documentenapi.client.DocumentStatusType
 import com.ritense.documentenapi.client.DocumentenApiClient
 import com.ritense.documentenapi.client.PatchDocumentRequest
@@ -135,7 +138,7 @@ class DocumentenApiPlugin(
         val contentAsInputStream = storageService.getResourceContentAsInputStream(resourceId)
         val metadata = storageService.getResourceMetadata(resourceId)
 
-        storeDocument(
+        val documentCreateResult = storeDocument(
             execution = execution,
             metadata = metadata,
             titel = null,
@@ -146,8 +149,34 @@ class DocumentenApiPlugin(
             inhoudAsInputStream = contentAsInputStream,
             beschrijving = null,
             informatieobjecttype = null,
-            storedDocumentUrl = DOCUMENT_URL_PROCESS_VAR,
+            storedDocumentUrl = "",
+        )
+
+        execution.setVariable(DOCUMENT_URL_PROCESS_VAR, documentCreateResult.url)
+    }
+
+    @PluginAction(
+        key = "store-uploaded-document-in-parts",
+        title = "Store uploaded document in parts",
+        description = "Store an uploaded document in the Documenten API in parts using the bestandsdelen api",
+        activityTypes = [ActivityTypeWithEventName.SERVICE_TASK_START]
+    )
+    fun storeUploadedDocumentInParts(
+        execution: DelegateExecution
+    ) {
+        val resourceId = execution.getVariable(RESOURCE_ID_PROCESS_VAR) as String?
+            ?: throw IllegalStateException("Failed to store document. No process variable '$RESOURCE_ID_PROCESS_VAR' found.")
+        val contentAsInputStream = storageService.getResourceContentAsInputStream(resourceId)
+        val metadata = storageService.getResourceMetadata(resourceId)
+
+        val documentCreateResult = storeDocumentInParts(
+            execution = execution,
+            metadata = metadata,
+            bestandsnaam = metadata["filename"].toString(),
+            inhoudAsInputStream = contentAsInputStream,
         )
+
+        execution.setVariable(DOCUMENT_URL_PROCESS_VAR, documentCreateResult.url)
     }
 
     @PluginAction(
@@ -245,7 +274,7 @@ class DocumentenApiPlugin(
         beschrijving: String?,
         informatieobjecttype: String?,
         storedDocumentUrl: String,
-    ) {
+    ): CreateDocumentResult {
         val vertrouwelijkheidaanduidingEnum = Vertrouwelijkheid.fromKey(
             vertrouwelijkheidaanduiding ?: getMetadataField(
                 metadata,
@@ -295,6 +324,59 @@ class DocumentenApiPlugin(
                 "Failed to set the $DOWNLOAD_URL_PROCESS_VAR variable in the DelegateExecution", e
             )
         }
+
+        return documentCreateResult
+    }
+
+    /**
+     * Using the bestandsdelen api a document can be uploaded in chunks. This upload method entails several api calls
+     * to store a document:
+     *  - First the document metadata is uploaded without the 'inhoud' parameter. The response of this method will
+     *    contain a 'lock' parameter that must be used in the next call
+     *  - Using the provided lock the contents of the file is uploaded to the bestandsdelen api
+     *  - When the complete file is uploaded the unlock api must be called. This will unlock the document enabling it
+     *    for download.
+     */
+    private fun storeDocumentInParts(
+        execution: DelegateExecution,
+        metadata: Map<String, Any?>,
+        bestandsnaam: String?,
+        inhoudAsInputStream: InputStream,
+    ):CreateDocumentResult {
+        val documentCreateResult = storeDocument(
+            execution = execution,
+            metadata = metadata,
+            titel = null,
+            vertrouwelijkheidaanduiding = null,
+            status = null,
+            taal = null,
+            bestandsnaam = bestandsnaam,
+            inhoudAsInputStream = InputStream.nullInputStream(),
+            beschrijving = null,
+            informatieobjecttype = null,
+            storedDocumentUrl = ""
+        )
+
+        val bestandsdelenRequest = BestandsdelenRequest(
+            inhoud = inhoudAsInputStream,
+            lock = documentCreateResult.getLockFromBestanddelen()
+        )
+
+        client.storeDocumentInParts(
+            authenticationPluginConfiguration,
+            url,
+            bestandsdelenRequest,
+            documentCreateResult,
+            bestandsnaam)
+
+        val documentLock = DocumentLock(documentCreateResult.getLockFromBestanddelen())
+        client.unlockDocument(
+            authenticationPluginConfiguration,
+            url,
+            documentLock,
+            documentCreateResult.getDocumentUUIDFromUrl())
+
+        return documentCreateResult
     }
 
     private fun getDocumentenApiPluginByInformatieobjectUrl(informatieobjectUrl: URI): PluginConfiguration {

zgw/documenten-api/src/main/kotlin/com/ritense/documentenapi/client/Bestandsdelen.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ritense.documentenapi.client
+
+class Bestandsdelen(
+    val url: String,
+    val volgnummer: Int,
+    val omvang: Int,
+    val voltooid: Boolean,
+    val lock: String
+)

zgw/documenten-api/src/main/kotlin/com/ritense/documentenapi/client/BestandsdelenRequest.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.ritense.documentenapi.client
+
+import java.io.InputStream
+
+class BestandsdelenRequest(
+    val inhoud: InputStream,
+    val lock:String
+)

zgw/documenten-api/src/main/kotlin/com/ritense/documentenapi/client/BestandsdelenResult.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class BestandsdelenResult(
+    var url: String?,
+    var lock: String?,
+    val voltooid: Boolean?,
+    val volgnummer: Int?,
+    val statusCode: Int?,
+    val errorMessage: String?
+)

zgw/documenten-api/src/main/kotlin/com/ritense/documentenapi/client/CreateDocumentResult.kt

@@ -24,4 +24,24 @@ class CreateDocumentResult(
     val bestandsnaam: String,
     val bestandsomvang: Long,
     val beginRegistratie: LocalDateTime,
-)
+    val bestandsdelen: List<Bestandsdelen>?
+) {
+    fun getBestandsdelenIdFromUrl(): String {
+        if (bestandsdelen.isNullOrEmpty()) {
+            return ""
+        }
+        return bestandsdelen[0].url.substring(bestandsdelen[0].url.lastIndexOf("/") + 1)
+    }
+
+    fun getLockFromBestanddelen(): String {
+        if (bestandsdelen.isNullOrEmpty()) {
+            return ""
+        }
+
+        return bestandsdelen[0].lock
+    }
+
+    fun getDocumentUUIDFromUrl(): String {
+        return url.substring(url.lastIndexOf("/") + 1)
+    }
+}

zgw/documenten-api/src/main/kotlin/com/ritense/documentenapi/client/DocumentenApiClient.kt

@@ -16,6 +16,7 @@
 
 package com.ritense.documentenapi.client
 
+import BestandsdelenResult
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.ritense.documentenapi.DocumentenApiAuthentication
 import com.ritense.documentenapi.domain.DocumentenApiColumnKey
@@ -30,13 +31,17 @@ import com.ritense.outbox.OutboxService
 import com.ritense.zgw.ClientTools
 import com.ritense.zgw.ClientTools.Companion.optionalQueryParam
 import com.ritense.zgw.Page
+import mu.KotlinLogging
+import org.springframework.core.io.ByteArrayResource
 import org.springframework.core.io.Resource
 import org.springframework.data.domain.PageImpl
 import org.springframework.data.domain.Pageable
 import org.springframework.http.MediaType
 import org.springframework.http.converter.ResourceHttpMessageConverter
 import org.springframework.transaction.PlatformTransactionManager
 import org.springframework.transaction.support.TransactionTemplate
+import org.springframework.util.LinkedMultiValueMap
+import org.springframework.util.MultiValueMap
 import org.springframework.web.client.RestClient
 import org.springframework.web.client.body
 import org.springframework.web.util.UriBuilder
@@ -72,6 +77,75 @@ class DocumentenApiClient(
         return result
     }
 
+     fun storeDocumentInParts(
+        authentication: DocumentenApiAuthentication,
+        baseUrl: URI,
+        request: BestandsdelenRequest,
+        createDocumentResult: CreateDocumentResult,
+        bestandsnaam: String?
+    ): BestandsdelenResult {
+         requireNotNull(bestandsnaam) { "Bestandsnaam must be set otherwise uploading in bestanddelen will fail" }
+
+         // Inside the CreateDocumentResult there is an array of bestandsdelen.
+         // Each bestandsdeel needs to be sent separately
+         // So the documenten api determines the amount of chunks, not this application.
+         val fileBytes = request.inhoud.readAllBytes()
+         var response: BestandsdelenResult? = null
+         var start = 0
+
+         logger.info("Starting upload of file in {} chunks\n", createDocumentResult.bestandsdelen?.size)
+
+         for(bestandsdeel in createDocumentResult.bestandsdelen!!) {
+             logger.info("Sending chunk #{} for a size of {}",
+                 bestandsdeel.volgnummer,
+                 bestandsdeel.omvang)
+
+             // Compute the correct end index of the chunk
+             val end = start + bestandsdeel.omvang
+             val chunk = fileBytes.copyOfRange(start, end)
+
+             val fileResource = object : ByteArrayResource(chunk) {
+                 override fun getFilename(): String {
+                     return bestandsnaam
+                 }
+             }
+
+             val body: MultiValueMap<String, Any> = LinkedMultiValueMap()
+             body.add("inhoud", fileResource)
+             body.add("lock", request.lock)
+
+             response = restClient(authentication)
+                 .put()
+                 .uri {
+                     ClientTools.baseUrlToBuilder(it, baseUrl)
+                         .path("bestandsdelen/{uuid}")
+                         .build(bestandsdeel.url.substring(bestandsdeel.url.lastIndexOf("/") + 1))
+                 }
+                 .contentType(MediaType.MULTIPART_FORM_DATA)
+                 .body(body)
+                 .retrieve()
+                 .body<BestandsdelenResult>()!!
+
+             start = end
+         }
+
+         return response ?: throw IllegalStateException("Upload in chunks failed")
+    }
+
+    fun unlockDocument(authentication: DocumentenApiAuthentication, baseUrl: URI,
+                       documentLock: DocumentLock, bestandsdelenId: String) {
+        restClient(authentication)
+            .post()
+            .uri { ClientTools.baseUrlToBuilder(it, baseUrl)
+                .path("enkelvoudiginformatieobjecten/{uuid}/unlock")
+                .build(bestandsdelenId)
+            }
+            .contentType(MediaType.APPLICATION_JSON)
+            .body(documentLock)
+            .retrieve()
+            .toBodilessEntity()
+    }
+
     fun getInformatieObject(
         authentication: DocumentenApiAuthentication,
         baseUrl: URI,
@@ -96,6 +170,7 @@ class DocumentenApiClient(
                 objectMapper.valueToTree(result)
             )
         }
+
         return result
     }
 
@@ -107,12 +182,8 @@ class DocumentenApiClient(
     ): org.springframework.data.domain.Page<DocumentInformatieObject> {
         // because the documenten api only supports a fixed page size, we will try to calculate the page we need to request
         // the only page sizes that are supported are those that can fit n times in the itemsPerPage
-        if (ITEMS_PER_PAGE % pageable.pageSize != 0) {
-            throw IllegalArgumentException("Page size is not supported")
-        }
-        if (documentSearchRequest.zaakUrl == null) {
-            throw IllegalArgumentException("Zaak URL is required")
-        }
+        require(ITEMS_PER_PAGE % pageable. pageSize == 0) { "Page size is not supported" }
+        requireNotNull(documentSearchRequest.zaakUrl) { "Zaak URL is required" }
 
         val pageToRequest = ((pageable.pageSize * pageable.pageNumber) / ITEMS_PER_PAGE) + 1
         val result =
@@ -297,5 +368,6 @@ class DocumentenApiClient(
 
     companion object {
         const val ITEMS_PER_PAGE = 100
+        var logger = KotlinLogging.logger{}
     }
 }