Insert Documents or Document Templates using Document Assembler

Clippit.Tests/Word/DocumentAssemblerTests.cs

@@ -3,8 +3,10 @@
 
 using System.Xml;
 using System.Xml.Linq;
+using System.Xml.XPath;
 using Clippit.Word;
 using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Validation;
 using Xunit;
 using static System.Runtime.InteropServices.JavaScript.JSType;
 
@@ -264,6 +266,52 @@ public void DA259(string name, string data, bool err)
             Assert.Equal(6, brCount);
         }
 
+        [Theory]
+        [InlineData("DA286-DocumentTemplate-Base-Main.docx", "DA286-DocumentTemplate-Base.xml", false)]
+        [InlineData(
+            "DA286-DocumentTemplate-MirroredMargins-Main.docx",
+            "DA286-DocumentTemplate-MirroredMargins.xml",
+            false
+        )]
+        [InlineData("DA286-DocumentTemplate-NoBreaks-Main.docx", "DA286-DocumentTemplate-NoBreaks.xml", false)]
+        [InlineData("DA286-DocumentTemplate-HeaderFooter-Main.docx", "DA286-DocumentTemplate-HeaderFooter.xml", false)]
+        [InlineData("DA286-Document-SolarSystem-Main.docx", "DA286-Document-SolarSystem.xml", false)]
+        public void DA286(string templateName, string data, bool err)
+        {
+            var templateDocx = new FileInfo(Path.Combine(_sourceDir.FullName, templateName));
+            var dataFile = new FileInfo(Path.Combine(_sourceDir.FullName, data));
+
+            var wmlTemplate = new WmlDocument(templateDocx.FullName, true);
+            var xmldata = XElement.Load(dataFile.FullName);
+
+            // set the directory for TemplatePath attributes
+            var ns = xmldata.GetDefaultNamespace();
+            foreach (var ele in xmldata.XPathSelectElements("//*[@TemplatePath]"))
+            {
+                var templatePath = ele.Attribute(ns + "TemplatePath").Value;
+                templatePath = Path.Combine(_sourceDir.FullName, templatePath);
+                ele.Attribute(ns + "TemplatePath").Value = templatePath;
+            }
+
+            // set the directory for Path attributes
+            foreach (var ele in xmldata.XPathSelectElements("//*[@Path]"))
+            {
+                var path = ele.Attribute(ns + "Path").Value;
+                path = Path.Combine(_sourceDir.FullName, path);
+                ele.Attribute(ns + "Path").Value = path;
+            }
+
+            var afterAssembling = DocumentAssembler.AssembleDocument(wmlTemplate, xmldata, out bool templateError);
+            var assembledDocx = new FileInfo(
+                Path.Combine(TempDir, templateDocx.Name.Replace(".docx", "-processed-by-DocumentAssembler.docx"))
+            );
+            afterAssembling.SaveAs(assembledDocx.FullName);
+
+            Validate(assembledDocx);
+
+            Assert.Equal(err, templateError);
+        }
+
         [Theory]
         [InlineData("DA024-TrackedRevisions.docx", "DA-Data.xml")]
         public void DA102_Throws(string name, string data)
@@ -275,7 +323,7 @@ public void DA102_Throws(string name, string data)
             var xmldata = XElement.Load(dataFile.FullName);
 
             WmlDocument afterAssembling;
-            Assert.Throws<OpenXmlPowerToolsException>(() =>
+            _ = Assert.Throws<OpenXmlPowerToolsException>(() =>
             {
                 afterAssembling = DocumentAssembler.AssembleDocument(
                     wmlTemplate,
@@ -368,6 +416,9 @@ private void Validate(FileInfo fi)
             "The 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:noVBand' attribute is not declared.",
             "The 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:oddHBand' attribute is not declared.",
             "The 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:oddVBand' attribute is not declared.",
+            "The 'http://schemas.microsoft.com/office/word/2012/wordml:restartNumberingAfterBreak' attribute is not declared.",
+            "The 'http://schemas.microsoft.com/office/word/2016/wordml/cid:durableId' attribute is not declared.",
+            "Attribute 'http://schemas.openxmlformats.org/wordprocessingml/2006/main:val' should have unique value. Its current value",
         };
     }
 }

Clippit/Word/Assembler/FileDataExtensions.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+namespace Clippit.Word.Assembler
+{
+    internal static class FileDataExtensions
+    {
+        internal static XElement GetBase64EncodedDocumentElement(this byte[] bytes)
+        {
+            // return a Content Control with byte[] base64 encoded
+            /*<w:sdt><w:sdtContent>
+                <w:p w:rsidR="00FB5781" w:rsidRDefault="00AE77E8">
+                <w:r><w:t>&lt;Document Data="BASE64" /&gt;</w:t></w:r></w:p></w:sdtContent></w:sdt>
+            */
+
+            var xmlString = $"<Document Data=\"{Convert.ToBase64String(bytes)}\" />";
+            XElement sdt = new XElement(
+                W.sdt,
+                new XElement(W.sdtContent, new XElement(W.p, new XElement(W.r, new XElement(W.t, xmlString))))
+            );
+
+            return sdt;
+        }
+    }
+}

Clippit/Word/Assembler/HtmlConverter.cs

@@ -1,6 +1,8 @@
 using System.Collections;
 using System.Text.RegularExpressions;
+using System.Xml;
 using System.Xml.Linq;
+using System.Xml.XPath;
 using Clippit.Html;
 using Clippit.Internal;
 using DocumentFormat.OpenXml.Packaging;

Clippit/Word/Assembler/PASchemaSet.cs

@@ -1,10 +1,21 @@
-using System.Xml.Schema;
+using System.Runtime.CompilerServices;
+using System.Xml;
+using System.Xml.Schema;
 
 namespace Clippit.Word.Assembler
 {
     internal class PASchemaSet
     {
-        public string XsdMarkup;
-        public XmlSchemaSet SchemaSet;
+        private readonly string XsdMarkup;
+        public readonly XmlSchemaSet SchemaSet;
+
+        internal PASchemaSet(string xsdMarkup)
+        {
+            this.XsdMarkup = xsdMarkup;
+            this.SchemaSet = new XmlSchemaSet();
+
+            XmlSchema schema = XmlSchema.Read(XmlReader.Create(new StringReader(XsdMarkup)), null);
+            this.SchemaSet.Add(schema);
+        }
     }
 }

Clippit/Word/Assembler/RunReplacementInfo.cs

@@ -0,0 +1,11 @@
+using System.Xml.Linq;
+
+namespace Clippit.Word.Assembler
+{
+    internal class RunReplacementInfo
+    {
+        public XElement Xml { get; set; }
+        public string XmlExceptionMessage { get; set; }
+        public string SchemaValidationMessage { get; set; }
+    }
+}

Clippit/Word/Assembler/XPathExtensions.cs

@@ -1,4 +1,5 @@
-using System.Collections;
+using System.Collections;
+using System.Xml;
 using System.Xml.Linq;
 using System.Xml.XPath;
 
@@ -58,5 +59,87 @@ internal static string EvaluateXPathToString(this XElement element, string xPath
                 _ => selectedData.First(),
             };
         }
+
+        internal static bool TryEvalueStringToByteArray(this XElement element, string pathOrXPath, out byte[] bytes)
+        {
+            bytes = [];
+
+            try
+            {
+                var fileInfo = element.EvaluateStringToFileInfo(pathOrXPath);
+                if (fileInfo != null)
+                {
+                    using (
+                        var fs = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)
+                    )
+                    {
+                        using (var ms = new MemoryStream())
+                        {
+                            fs.CopyTo(ms);
+                            bytes = ms.ToArray();
+                        }
+                    }
+
+                    return true;
+                }
+            }
+            catch { }
+
+            return false;
+        }
+
+        private static FileInfo EvaluateStringToFileInfo(this XElement element, string pathOrXPath)
+        {
+            object xPathSelectResult;
+            try
+            {
+                xPathSelectResult = element.XPathEvaluate(pathOrXPath);
+                if ((xPathSelectResult is IEnumerable) && !(xPathSelectResult is string))
+                {
+                    var selectedData = ((IEnumerable)xPathSelectResult).Cast<XObject>().SingleOrDefault();
+                    if (selectedData != null)
+                    {
+                        if (selectedData.NodeType == XmlNodeType.Text)
+                        {
+                            XText text = selectedData as XText;
+                            return new FileInfo(text.Value);
+                        }
+                        else if (selectedData.NodeType == XmlNodeType.Attribute)
+                        {
+                            XAttribute att = selectedData as XAttribute;
+                            return new FileInfo(att.Value);
+                        }
+                        else if (selectedData.NodeType == XmlNodeType.Element)
+                        {
+                            // the element should have one child text node
+                            XElement ele = selectedData as XElement;
+                            XText text = ele.Nodes()
+                                .Where(x => x.NodeType == XmlNodeType.Text)
+                                .Select(x => x as XText)
+                                .SingleOrDefault();
+
+                            if (text != null)
+                            {
+                                return new FileInfo(text.Value);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (XPathException) // suppress the xpath exception
+            { }
+
+            // check whether the xPath is actually just a file path
+            try
+            {
+                return new FileInfo(pathOrXPath);
+            }
+            // supress exceptions that may occur if the path is actually xPath
+            catch (ArgumentNullException) { }
+            catch (NotSupportedException) { }
+            catch (ArgumentException) { }
+
+            return null;
+        }
     }
 }