fix: Read resources from classpath (#2)

* fix: Read resources from classpath

* Legg til dokumentasjon

* Legg til api for å opprette PDF direkte fra json og template

Author: ugur93

README.md

@@ -17,6 +17,38 @@ Most commonly, pdfgen-core is used with templates, fonts, additional resources,
 Check GitHub releases to find the latest `release` version 
 Check [Github releases](https://github.com/navikt/pdfgen-core/releases) to find the latest `release` version
 
+In your own repository create subfolders in `templates` and `data`
+```bash
+mkdir {templates,data}/directory_name # directory_name can be anything, but it'll be a necessary part of the API later
+````
+* `templates/directory_name/` should then be populated with your .hbs-templates. the names of these templates will also decide parts of the API paths
+* `data/directory_name/` should be populated with json files with names corresponding to a target .hbs-template, this can be used to test your PDFs during development of templates.
+
+Additionally create subfolder `resources` containing additional resources which can be referred in your .hbs-templates
+
+
+### Example usage
+#### Generating HTML from predefined JSON data in data-folder
+```kotlin
+
+val html: String = createHtmlFromTemplateData(template, directoryName)
+```
+
+#### Generating PDF from predefined JSON data in data-folder
+```kotlin
+val html: String = createHtmlFromTemplateData(template, directoryName)
+val pdfBytes: ByteArray = createPDFA(html)
+```
+
+#### Generating from JSON input data
+```kotlin
+val html: String = createHtmlFromTemplateData(template, directoryName, jsonNode)
+val pdfBytes: ByteArray = createPDFA(html)
+
+// Or directly
+val pdfBytes: ByteArray = createPDFA(template, directoryName, jsonNode)
+```
+
 ## Developing pdfgen-core
 
 ### Build and run tests

build.gradle.kts

@@ -1,5 +1,5 @@
 group = "no.nav.pdfgen"
-version = properties["version"]?.takeIf { it is String && it.isNotEmpty() } ?: "local-build"
+version = properties["version"]?.takeIf { it is String && it.isNotEmpty() && it != "unspecified" } ?: "local-build"
 println(version)
 
 val handlebarsVersion = "4.3.1"

src/main/kotlin/no/nav/pdfgen/core/Environment.kt

@@ -2,19 +2,23 @@ package no.nav.pdfgen.core
 
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.module.kotlin.readValue
+import io.github.oshai.kotlinlogging.KotlinLogging
+import no.nav.pdfgen.core.util.FontMetadata
+import org.apache.pdfbox.io.IOUtils
+import java.io.File
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
-import java.util.*
+import java.util.Base64
 import kotlin.io.path.exists
 import kotlin.io.path.extension
-import no.nav.pdfgen.core.util.FontMetadata
-import org.apache.pdfbox.io.IOUtils
-
+import kotlin.io.path.pathString
+import kotlin.io.path.readBytes
+private val log = KotlinLogging.logger {}
 val objectMapper: ObjectMapper = ObjectMapper().findAndRegisterModules()
-val templateRoot: Path = getFromEnvOrDefault("TEMPLATES_PATH", "templates/")
-val imagesRoot: Path = getFromEnvOrDefault("RESOURCES_PATH", "resources/")
-val fontsRoot: Path = getFromEnvOrDefault("FONTS_PATH", "fonts/")
+val templateRoot: PDFGenResource = PDFGenResource("TEMPLATES_PATH", "templates/")
+val imagesRoot: PDFGenResource = PDFGenResource("RESOURCES_PATH", "resources/")
+val fontsRoot: PDFGenResource = PDFGenResource("FONTS_PATH", "fonts/")
 
 class PDFgen {
     companion object {
@@ -34,7 +38,7 @@ data class Environment(
     val colorProfile: ByteArray =
         IOUtils.toByteArray(Environment::class.java.getResourceAsStream("/sRGB2014.icc")),
     val fonts: List<FontMetadata> =
-        objectMapper.readValue(Files.newInputStream(fontsRoot.resolve("config.json"))),
+        objectMapper.readValue(fontsRoot.readAllBytes("config.json")),
     val disablePdfGet: Boolean = System.getenv("DISABLE_PDF_GET")?.let { it == "true" } ?: false,
     val enableHtmlEndpoint: Boolean =
         System.getenv("ENABLE_HTML_ENDPOINT")?.let { it == "true" } ?: false,
@@ -53,17 +57,26 @@ data class Environment(
     }
 }
 
-private fun getFromEnvOrDefault(envVariableName: String, defaultPath: String): Path {
-    return System.getenv(envVariableName)?.let { Paths.get(it) }
-        ?: run {
-            val fromDefaultPath = Paths.get(defaultPath)
-            return if (fromDefaultPath.exists()) fromDefaultPath
-            else Paths.get(ClassLoader.getSystemResource(defaultPath).file.toString())
-        }
+data class PDFGenResource(val envVariableName: String, val defaultPath: String){
+
+    private val _path: Path = System.getenv(envVariableName)?.let { Paths.get(it) }
+        ?: Paths.get(defaultPath)
+    fun readAllBytes(filename: String? = null): ByteArray {
+        val filePath = filename?.let { _path.resolve(it) } ?: _path
+        return if (filePath.exists()) filePath.readBytes() else Environment::class.java.classLoader.getResourceAsStream(filePath.pathString)!!.readAllBytes()
+    }
+
+    fun toFile(filename: String? = null): File = getPath(filename).toFile()
+
+    fun getPath(filename: String? = null): Path {
+        val filePath = filename?.let { _path.resolve(it) } ?: _path
+        log.debug { "Reading file from path $filePath. File exists on path = ${filePath.exists()}" }
+        return if (filePath.exists()) filePath else Path.of(Environment::class.java.classLoader.getResource(filePath.pathString)!!.toURI())
+    }
 }
 
 private fun loadImages() =
-    Files.list(imagesRoot)
+    Files.list(imagesRoot.getPath())
         .filter {
             val validExtensions = setOf("jpg", "jpeg", "png", "bmp", "svg")
             !Files.isHidden(it) && it.fileName.extension in validExtensions
@@ -84,7 +97,7 @@ private fun loadImages() =
         .toMap()
 
 private fun loadResources() =
-    Files.list(imagesRoot)
+    Files.list(imagesRoot.getPath())
         .filter {
             val validExtensions = setOf("svg")
             !Files.isHidden(it) && it.fileName.extension in validExtensions

src/main/kotlin/no/nav/pdfgen/core/MetricRegistry.kt

@@ -4,17 +4,13 @@ import io.prometheus.client.Summary
 
 val HANDLEBARS_RENDERING_SUMMARY: Summary =
     Summary.Builder()
-        .name("handlebars_rendering")
+        .name("pdfgen_core_handlebars_rendering")
         .help("Time it takes for handlebars to render the template")
         .register()
 val OPENHTMLTOPDF_RENDERING_SUMMARY: Summary =
     Summary.Builder()
-        .name("openhtmltopdf_rendering_summary")
+        .name("pdfgen_core_openhtmltopdf_rendering_summary")
         .help("Time it takes to render a PDF")
         .labelNames("application_name", "template_type")
         .register()
-val JSOUP_PARSE_SUMMARY: Summary =
-    Summary.Builder()
-        .name("jsoup_parse")
-        .help("Time it takes jsoup to parse the template")
-        .register()
+

src/main/kotlin/no/nav/pdfgen/core/pdf/CreateHtml.kt

@@ -14,21 +14,21 @@ import no.nav.pdfgen.core.template.loadTemplates
 
 private val log = KotlinLogging.logger {}
 
-fun createHtml(template: String, applicationName: String, jsonPayload: JsonNode): String? {
+fun createHtml(template: String, directoryName: String, jsonPayload: JsonNode): String? {
     log.debug { "${"JSON: {}"} ${objectMapper.writeValueAsString(jsonPayload)}" }
-    return render(applicationName, template, jsonPayload)
+    return render(directoryName, template, jsonPayload)
 }
 
-fun createHtmlFromTemplateData(template: String, applicationName: String): String? {
-    val jsonNode = hotTemplateData(applicationName, template)
+fun createHtmlFromTemplateData(template: String, directoryName: String): String? {
+    val jsonNode = hotTemplateData(directoryName, template)
     log.debug { "${"JSON: {}"} ${objectMapper.writeValueAsString(jsonNode)}" }
-    return render(applicationName, template, jsonNode)
+    return render(directoryName, template, jsonNode)
 }
 
-private fun render(applicationName: String, template: String, jsonNode: JsonNode): String? {
+private fun render(directoryName: String, template: String, jsonNode: JsonNode): String? {
     return HANDLEBARS_RENDERING_SUMMARY.startTimer()
         .use {
-            loadTemplates()[applicationName to template]?.apply(
+            loadTemplates()[directoryName to template]?.apply(
                 Context.newBuilder(jsonNode)
                     .resolver(
                         JsonNodeValueResolver.INSTANCE,

src/main/kotlin/no/nav/pdfgen/core/pdf/Create.kt src/main/kotlin/no/nav/pdfgen/core/pdf/CreatePdf.kt

@@ -1,5 +1,6 @@
 package no.nav.pdfgen.core.pdf
 
+import com.fasterxml.jackson.databind.JsonNode
 import com.openhtmltopdf.pdfboxout.PdfRendererBuilder
 import com.openhtmltopdf.svgsupport.BatikSVGDrawer
 import io.github.oshai.kotlinlogging.KotlinLogging
@@ -32,6 +33,10 @@ import org.verapdf.pdfa.results.TestAssertion
 
 private val log = KotlinLogging.logger {}
 
+fun createPDFA(template: String, directoryName: String, jsonPayload: JsonNode? = null): ByteArray? {
+    val html = jsonPayload?.let { createHtml(template, directoryName, it) } ?: createHtmlFromTemplateData(template, directoryName)
+    return html?.let { createPDFA(it) }
+}
 fun createPDFA(html: String): ByteArray {
     val pdf =
         ByteArrayOutputStream()

src/main/kotlin/no/nav/pdfgen/core/template/Templates.kt

@@ -17,7 +17,7 @@ fun setupHandlebars() =
     }
 
 fun loadTemplates(): TemplateMap =
-    Files.list(templateRoot)
+    Files.list(templateRoot.getPath())
         .filter { !Files.isHidden(it) && Files.isDirectory(it) }
         .map {
             it.fileName.toString() to Files.list(it).filter { b -> b.fileName.extension == "hbs" }

src/main/kotlin/no/nav/pdfgen/core/util/FontMetadata.kt

@@ -1,7 +1,6 @@
 package no.nav.pdfgen.core.util
 
 import com.openhtmltopdf.outputdevice.helper.BaseRendererBuilder
-import java.nio.file.Files
 import no.nav.pdfgen.core.fontsRoot
 
 data class FontMetadata(
@@ -11,5 +10,5 @@ data class FontMetadata(
     val style: BaseRendererBuilder.FontStyle,
     val subset: Boolean,
 ) {
-    val bytes: ByteArray = Files.readAllBytes(fontsRoot.resolve(path))
+    val bytes: ByteArray = fontsRoot.readAllBytes(path)
 }