Updated the project to v1.2 with the following:

 - Added support for Custom Font integration as Resource Files in the project and deployed with the JAR!
 - Added a a couple sample (free) custom fonts and sample markup `resources/samples/WorkinWithFontsSampe.fo` in the project.
 - Fixed bug in the render Event Log debug details returned in the Http Header whereby Apache FOP may send Unicode Characters but only ASCII are allowed; Unicode are now safely escaped into their respective Hex Codes so that the message is readable.
 - Fixed issue in Maven build to enforce the clean stage so the artifact always contains the latest changes (e.g. especially physical resource file changes) when debugging.
 - Some miscellaneous code cleanup.

Author: cajuncoding

README.md

@@ -14,7 +14,15 @@ then I do love-me-some-coffee!*
 </a> 
 
 ## Updates
-Updated the project to v1.1 as it now incorporates the following new updates:
+**Updated the project to v1.2 with the following:**
+ - Added support for Custom Font integration as Resource Files in the project and deployed with the JAR!
+   - This enables adding fonts easily by simply dropping them in the `resources/fonts` folder, and then registering them via configuration in the `apache-fop-config.xml` according to [Apache FOP Font Documentation](https://xmlgraphics.apache.org/fop/2.6/fonts.html#register).
+   - Added a a couple sample (free) custom fonts and sample markup `resources/samples/WorkinWithFontsSampe.fo` in the project.
+ - Fixed bug in the render Event Log debug details returned in the Http Header whereby Apache FOP may send Unicode Characters but only ASCII are allowed; Unicode are now safely escaped into their respective Hex Codes so that the message is readable.
+ - Fixed issue in Maven build to enforce the clean stage so the artifact always contains the latest changes (e.g. especially physical resource file changes) when debugging.
+ - Some miscellaneous code cleanup.
+
+Updated the project to v1.1 as it now incorporates:
  - Upgraded the project to use Java v11 now as the latest long term supported (LTS) version for Azure Functions (aka Zulu Java v11)
    - _Previously was Java 8 (v1.8) (aka Zulu Java v8)._
  - Bumping the versions of all dependencies to the latest stable versions
@@ -97,7 +105,7 @@ Here's the high level steps to get started...
 
 ## Additional Features:
 
-#### GZIP Compression:
+### GZIP Compression:
 In addition to rendering the PDF, this service already implements GZIP compression for returning the Binary PDF files. This can greatly improve performance and download times, especially for PDFs rendered without much imagery, as the text content bytes tends to be more compressible.
 
 All you need to do is add the `Accept-Encoding` header with a value of `gzip` to the request:
@@ -108,6 +116,45 @@ Accept-Encoding=gzip
     <img src="/postman-header-enable-gzip.png" style="width:auto;height:auto;max-width:800px;">
 </p>
 
+### Custom Fonts via Resource Files:
+##### Add Font Files (*.ttf, *.otf, etc.)
+To easily utilize custom fonts with the Azure Functions deployment, this project provides the ability to simply add them into the project as resource
+files by simply placing them in the `src/main/resources/fonts` folder.  So you can literally just copy them into the project and deploy. In IntelliJ IDEA the structure will look like:
+<p align="center">
+    <img src="/intellij-resources-fonts-project-structure.png" style="width:auto;height:auto;max-width:500px;">
+</p>
+
+Once there they can be resolved at runtime by the application even after being deployed to Azure Functions; because they will be embedded resources with the JAR file. ApacheFOP.Serverless has a custom `ResourceResolver` implementation that can then locate these via relative path is used when registering the fonts via configuration in the `apache-fop-config.xml` according to [Apache FOP Font Documentation](https://xmlgraphics.apache.org/fop/2.6/fonts.html#register).
+
+##### Register them with Apache FOP Configuration:
+Now we need to register the fonts we've placed into our resources.  We do this by editing the `resources/apache-fop-config.xml` according to [Apache FOP Font Documentation](https://xmlgraphics.apache.org/fop/2.6/fonts.html#register).  The project includes a couple sample fonts as well as a sample Xsl FO markup file that will render using these new custom fonts located at `resources/samples/WorkinWithFontsSample.fo`.
+
+The font registration configuration looks like this:
+```
+<fop version="1.0">
+  . . . 
+  <renderers>
+    <renderer mime="application/pdf">
+      . . . 
+      
+      <fonts>
+        <!-- Automatically detect operating system installed fonts; More Details Here: https://xmlgraphics.apache.org/fop/2.6/fonts.html -->
+        <auto-detect/>
+
+        <font embed-url="fonts/Minisystem.ttf" simulate-style="true">
+            <font-triplet name="Minisystem" style="normal" weight="normal" />
+        </font>
+        <font embed-url="fonts/PixelWow.otf" simulate-style="true">
+            <font-triplet name="PixelWow" style="normal" weight="normal" />
+        </font>
+    </fonts>
+    . . . 
+    </renderer>
+  </renderers>
+</fop>
+```
+
+
 ## Calling the Service from .Net
 
 ### Snippet:

apachefop-serverless-az-func/.gitignore

@@ -28,7 +28,6 @@ hs_err_pid*
 .settings/
 .project
 .classpath
-.vscode/
 
 # macOS
 .DS_Store

apachefop-serverless-az-func/pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.cajuncoding</groupId>
     <artifactId>apachefop-serverless-az-func</artifactId>
-    <version>1.1-SNAPSHOT</version>
+    <version>1.2-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>Azure Java Functions</name>
@@ -14,6 +14,8 @@
         <java.version>11</java.version>
         <appBaseName>apachefop-serverless-az-func</appBaseName>
         <stagingDirectory>${project.build.directory}/azure-functions/${appBaseName}</stagingDirectory>
+        <functionAppName>apachefop-serverless-az-func</functionAppName>
+        <!-- <functionAppRegion>westus</functionAppRegion> -->
     </properties>
 
     <dependencies>
@@ -32,6 +34,12 @@
             <artifactId>commons-lang3</artifactId>
             <version>3.12.0</version>
         </dependency>
+        <dependency>
+            <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-text -->
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-text</artifactId>
+            <version>1.9</version>
+        </dependency>
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>
@@ -154,6 +162,7 @@
                 <artifactId>maven-resources-plugin</artifactId>
                 <version>3.2.0</version>
                 <executions>
+                    <!-- COPY Azure Function configuration JSON Files (required especially for running locally)! -->
                     <execution>
                         <id>copy-resources</id>
                         <phase>package</phase>
@@ -210,6 +219,15 @@
                         </fileset>
                     </filesets>
                 </configuration>
+                <executions>
+                    <execution>
+                        <id>auto-clean</id>
+                        <phase>initialize</phase>
+                        <goals>
+                            <goal>clean</goal>
+                        </goals>
+                    </execution>
+                </executions>
             </plugin>
         </plugins>
     </build>

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/ApacheFopFunction.java

@@ -1,19 +1,21 @@
 package com.cajuncoding.apachefop.serverless;
 
+import com.cajuncoding.apachefop.serverless.apachefop.ApacheFopRenderer;
 import com.cajuncoding.apachefop.serverless.web.ApacheFopServerlessFunctionExecutor;
 import com.microsoft.azure.functions.*;
 import com.microsoft.azure.functions.annotation.AuthorizationLevel;
 import com.microsoft.azure.functions.annotation.FunctionName;
 import com.microsoft.azure.functions.annotation.HttpTrigger;
 
 import java.util.Optional;
+import java.util.logging.Level;
 
 /**
  * Azure Functions with HTTP Trigger.
  */
 public class ApacheFopFunction {
     /**
-     * This function listens at endpoint "/api/apache-fop/xslfo". Two ways to invoke it using "curl" command in bash:
+     * This function listens at endpoint "/api/apache-fop/xslfo".
      */
     @FunctionName("ApacheFOP")
     public HttpResponseMessage run(

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/ApacheFopGzipFunction.java

@@ -13,7 +13,7 @@
  */
 public class ApacheFopGzipFunction {
     /**
-     * This function listens at endpoint "/api/apache-fop/xslfo". Two ways to invoke it using "curl" command in bash:
+     * This function listens at endpoint "/api/apache-fop/gzip".
      */
     @FunctionName("ApacheFOPGzip")
     public HttpResponseMessage run(

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/apachefop/ApacheFopJavaResourcesFileResolver.java

@@ -0,0 +1,51 @@
+package com.cajuncoding.apachefop.serverless.apachefop;
+
+import com.cajuncoding.apachefop.serverless.utils.ResourceUtils;
+import org.apache.fop.apps.io.ResourceResolverFactory;
+import org.apache.xmlgraphics.io.Resource;
+import org.apache.xmlgraphics.io.ResourceResolver;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.nio.file.Paths;
+
+public class ApacheFopJavaResourcesFileResolver implements ResourceResolver {
+
+    public static final String FILE_SCHEME = "file";
+
+    private static final ResourceResolver defaultFopResolver = ResourceResolverFactory.createDefaultResourceResolver();
+
+    @Override
+    public Resource getResource(URI uri) throws IOException {
+        InputStream resourceStream = null;
+
+        //We MUST ONLY attempt to handle FILE requests... any Http/Https requests need to use original/default behaviour!
+        if(uri.getScheme().equalsIgnoreCase(FILE_SCHEME)) {
+            //Map the requested Uri to the base application path to determine it's relative path as a Resource!
+            var requestPath = Paths.get(uri);
+            var mappedPath = ResourceUtils.MapServerPath(requestPath);
+
+            //Now with the relative path for our resource we can attempt to retrieve it...
+            resourceStream = ResourceUtils.LoadResourceAsStream(mappedPath.toString());
+        }
+
+        //If the resource was located then we return it...
+        //Otherwise we fallback to default Apache FOP behaviour using the original default Fop Resource Resolver...
+        return resourceStream != null
+            ? new Resource(resourceStream)
+            : defaultFopResolver.getResource(uri);
+    }
+
+    @Override
+    public OutputStream getOutputStream(URI uri) throws IOException {
+        //For Output Streams we simply default to original Apache FOP behaviour using the original default Fop Resource Resolver...
+        return defaultFopResolver.getOutputStream(uri);
+
+        //return ResourceUtils.GetClassLoader()
+        //        .getResource(uri.toString())
+        //        .openConnection()
+        //        .getOutputStream();
+    }
+}

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/apachefop/ApacheFopRenderer.java

@@ -1,5 +1,6 @@
 package com.cajuncoding.apachefop.serverless.apachefop;
 
+import com.cajuncoding.apachefop.serverless.config.ApacheFopServerlessConfig;
 import com.cajuncoding.apachefop.serverless.config.ApacheFopServerlessConstants;
 import org.apache.fop.apps.*;
 import org.apache.fop.configuration.ConfigurationException;
@@ -14,6 +15,9 @@
 import java.util.zip.GZIPOutputStream;
 
 public class ApacheFopRenderer {
+    //Provide Dynamic resolution of Resources (e.g. Fonts) from JAR Resource Files...
+    private static final ApacheFopJavaResourcesFileResolver fopResourcesFileResolver = new ApacheFopJavaResourcesFileResolver();
+
     //FOPFactory is expected to be re-used as noted in Apache 'overview' section here:
     //  https://xmlgraphics.apache.org/fop/1.1/embedding.html
     private static final FopFactory fopFactory = createApacheFopFactory();
@@ -22,9 +26,10 @@ public class ApacheFopRenderer {
     private static final TransformerFactory transformerFactory = TransformerFactory.newInstance();
 
     private Logger logger = null;
+    private ApacheFopServerlessConfig apacheFopConfig = null;
 
     public ApacheFopRenderer() {
-        this.logger = null;
+        this(null);
     }
 
     public ApacheFopRenderer(Logger optionalLogger) {
@@ -85,7 +90,8 @@ public static FopFactory createApacheFopFactory() {
                 //Attempt to initialize with Configuration loaded from Configuration XML Resource file...
                 var cfgBuilder = new DefaultConfigurationBuilder();
                 var cfg = cfgBuilder.build(configStream);
-                var fopFactoryBuilder = new FopFactoryBuilder(baseUri).setConfiguration(cfg);
+
+                var fopFactoryBuilder = new FopFactoryBuilder(baseUri, fopResourcesFileResolver).setConfiguration(cfg);
 
                 fopFactory = fopFactoryBuilder.build();
             }

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/utils/ResourceUtils.java

@@ -5,18 +5,50 @@
 import org.apache.commons.io.IOUtils;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 
 public class ResourceUtils {
 
     public static String LoadResourceAsString(String resource) throws IOException {
-        return LoadResourceAsString(resource, ResourceUtils.class.getClassLoader());
+        return LoadResourceAsString(resource, GetClassLoader());
     }
 
     public static String LoadResourceAsString(String resource, ClassLoader resourceClassLoader) throws IOException {
-        try (var xslFoStream = resourceClassLoader.getResourceAsStream(resource);) {
-            var resourceText = IOUtils.toString(xslFoStream, StandardCharsets.UTF_8);
+        var sanitizedResource = SanitizeResourcePath(resource);
+
+        try (var resourceStream = resourceClassLoader.getResourceAsStream(sanitizedResource);) {
+            var resourceText = IOUtils.toString(resourceStream, StandardCharsets.UTF_8);
             return resourceText;
         }
     }
+
+    public static InputStream LoadResourceAsStream(String resource) {
+        var sanitizedResource = SanitizeResourcePath(resource);
+        var resourceStream = GetClassLoader().getResourceAsStream(sanitizedResource);
+        return resourceStream;
+    }
+
+    public static Path GetBaseMappedPath() {
+        var baseAppPath = Paths.get("").toAbsolutePath();
+        return baseAppPath;
+    }
+
+    public static Path MapServerPath(Path pathToMap) {
+        var basePath = GetBaseMappedPath();
+        var relativePath = basePath.relativize(pathToMap);
+        return relativePath;
+    }
+
+    public static ClassLoader GetClassLoader() {
+        return ResourceUtils.class.getClassLoader();
+    }
+
+    public static String SanitizeResourcePath(String resource) {
+        var trimmed = resource.trim();
+        var slashCorrected = trimmed.indexOf('\\') < 0 ? trimmed : trimmed.replace('\\', '/');
+        return slashCorrected;
+    }
 }

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/utils/TextUtils.java

@@ -18,6 +18,10 @@ public static String getCurrentW3cDateTime() {
         return currentW3cDateTime;
     }
 
+    public static boolean IsNullOrWhiteSpace(String value) {
+        return value == null || value.isBlank();
+    }
+
     /**
      * Truncates a string to the number of characters that fit in X bytes avoiding multi byte characters being cut in
      * half at the cut off point. Also handles surrogate pairs where 2 characters in the string is actually one literal

apachefop-serverless-az-func/src/main/java/com/cajuncoding/apachefop/serverless/web/SafeHeader.java

@@ -1,13 +1,35 @@
 package com.cajuncoding.apachefop.serverless.web;
 
+import com.cajuncoding.apachefop.serverless.http.HttpEncodings;
+import com.cajuncoding.apachefop.serverless.utils.TextUtils;
+import org.apache.commons.text.StringEscapeUtils;
+import org.w3c.dom.Text;
+
+import java.io.UnsupportedEncodingException;
+
 public class SafeHeader {
     private String value;
     private String encoding;
-    public SafeHeader(String value, String encoding) {
-        this.value = value;
-        this.encoding = encoding;
+
+    public SafeHeader(String value, String encoding) throws UnsupportedEncodingException {
+        this.value = sanitizeTextForHttpHeader(value, encoding);
+        this.encoding = sanitizeTextForHttpHeader(encoding, null);
     }
 
     public String getEncoding() { return encoding; }
     public String getValue() { return value; }
+
+    protected String sanitizeTextForHttpHeader(String value, String encoding) throws UnsupportedEncodingException {
+        if(TextUtils.IsNullOrWhiteSpace(value))
+            return value;
+
+        if(encoding != null && encoding != HttpEncodings.IDENTITY_ENCODING)
+            return value;
+
+        //BBernard - 09/29/2021
+        //FIX bug where ApacheFOP may return Unicode Characters in Event Messages whereby we must escape any
+        //  Unicode Characters in the Header Text because onlY ASCII characters are valid.
+        var sanitizedValue = StringEscapeUtils.escapeJava(value);
+        return sanitizedValue;
+    }
 }