The Engine Room

Recently I was responsible for generating an Invoice report using Open XML format of Office 2007. The report was developed using Word 2007, Word 2007 Content Control Toolkit, VS.Net 2005 (.Net 3.0), and SQL Server 2005. Most of the data was dynamically added to the invoice report using content controls and XML data manipulation.

This was part of a migration exercise with one of our internal applications where we replaced all of our Active Reports reports to SQL Server Reporting Services (SSRS) except one. That report was created in Word 2007.

One of the reasons for using Open XML format for this report is that the SSRS didn't provide us with enough flexibility of using custom fonts and formatting the data. Another reason was to avoid upgrading license fee for Active Reports for .Net 2.0 (which I believe should be free).
If you like an introduction to the new Open XML format in Office 2007 then please read this article.

Content controls
Content controls were introduced in Word 2007 to give developers the flexibility of creating editable placeholders. These content controls can be mapped to the data in Word's Custom XML file for pre-populating the document with dynamic data. There are different types of content controls available in Word 2007 like Text Box (including Rich Text), Picture, Combo and Drop down list, Calendar and ActiveX controls. These controls provide us with enough flexibility for generating a basic Word document dynamically. You can find out more about adding content controls to a Word 2007 document here.
This image shows the design view of a word document with few Content controls.

Content Control Toolkit
I came across this very handy tool called Content Control Toolkit which enabled me to map the content controls to the fields in Custom XML files of Word 2007 as easy as drag and drop. You can read more about this toolkit here. This toolkit does not require Word 2007 to be installed on your machine because it operates directly on the new Open XML file format using System.IO.Packaging library available in .Net 3.0 (you just need to have .Net 3.0 installed on the server). But it is recommended that you have Word 2007 installed to see any changes you make to the document.
The System.IO.Packaging library available in .Net 3.0 is very useful for manipulating the data in any Office 2007 documents. You can use the package and packagepart objects to access the XML documents in the Word 2007.

The Process
The process of generating the invoice report involved using content controls and manipulating the XML data. A template was created with all the content controls placed in a desired format. A copy of this template was used every time a new invoice report was generated.
The content controls were used for non-repeating fields like Client Name, Invoice Amount, and Invoice Number etc. You can find out more about adding content controls and mapping them to the custom XML file here. The XML data in custom XML file was then updated with the respective data retrieved from the database.
One of the challenges we faced during the process was that Word 2007 doesn't have repeating content controls. As a work around we used data manipulation method for repeating contents like line items. A table was added to the template. The table had one row for line items with some placeholder text in each cell. The row was then programmatically accessed by looping through the tables in the document and searching for the row containing the placeholder string.
Before you even start coding you need to

• Prepare an invoice template in Word 2007
• Add content controls to a Word 2007
• Add a table for invoice line items
• Map the content controls to the custom XML, preferably using content control toolkit

Once you've done that, you basically apply the following logic to create an invoice report programmatically

• Make a copy of the invoice template and open it using Package object
• Access the document's XML files using PackagePart object
• Create line items by adding rows to the line item table
• Update the document's Custom XML file to pre-populate the data in content controls
• Save the changes made to all XML files

The following is a brief step by step guide on how to create an invoice report. I am not saying this is the only way to do it but this is what worked for me. Please note that I've included only the important steps and have left out easy tasks for you to figure out.

Opening a Word document
The document can be opened by using the Package object. A package is a collection of package parts consisting of XML files (like document.xml, item1.xml etc).
Open the Word document from a specified path sFileName file as below
// Given a file name, retrieve the officeDocument part.
const string sDocumentRelationshipType = "http://schemas.openxmlformats.org/
officeDocument/2006/relationships/officeDocument";
// Open the package with read/write access.
using (Package pkgDocPackage = Package.Open(sFileName, FileMode.Open, FileAccess.ReadWrite))
{
// Get the main document part (workbook.xml, document.xml, presentation.xml).
foreach (System.IO.Packaging.PackageRelationship rlsRelationship in pkgDocPackage.GetRelationshipsByType
(sDocumentRelationshipType))
{
//Do the document formatting fisrt (in this case populate the line items)
//Do the custom xml formatting (in this case replace the custom xml with invoice details)
} }

Accessing XML files
Once the Word document is opened, the XML files in the document structure can then be accessed and manipulated by instantiating a Package Part object. A Package Part can be instantiated using the URI stored in the PackageRelationship object.
Load the content of document.xml into an XmlDocument object as below
// Get the Package Part for this document
Uri uMainDocumentUri = PackUriHelper.ResolvePartUri(new Uri("/", UriKind.Relative), rlsRelationship.TargetUri);
PackagePart ppDocPkgPart = pkgDocPackage.GetPart(uMainDocumentUri);
// Load the xml to a XmlDocument by streaming the package part
XmlDocument xmlMainXMLDoc = new XmlDocument();
xmlMainXMLDoc.Load(ppDocPkgPart.GetStream(FileMode.Open, FileAccess.Read));
Make sure that you use the appropriate URI path for the files you are trying to access. For example, use new Uri("/customXML/item.xml", UriKind.Relative) if you are trying to access any of the custom XML files. A "/" points to the document.xml file.
Assign namespaces to the xml document as below
XmlNamespaceManager nsmgr = CreateNamespaceManager(xmlMainXMLDoc);

Namespaces
There are bunch of namespaces that you will be using while accessing the Open XML format of typical Word 2007 document. Below are some of the namespaces I had used.
public XmlNamespaceManager CreateNamespaceManager(XmlDocument xmlDoc)
{
// Define all the namespaces
XmlNamespaceManager nmNamespaceMgr = new XmlNamespaceManager(xmlDoc.NameTable);
nmNamespaceMgr.AddNamespace("ve", "http://schemas.openxmlformats.org/
markup-compatibility/2006");
nmNamespaceMgr.AddNamespace("o", "urn:schemas-microsoft-com:office:office");
nmNamespaceMgr.AddNamespace("r", "http://schemas.openxmlformats.org/
officeDocument/2006/relationships");
nmNamespaceMgr.AddNamespace("m", "http://schemas.openxmlformats.org/
officeDocument/2006/math");
nmNamespaceMgr.AddNamespace("v", "urn:schemas-microsoft-com:vml");
nmNamespaceMgr.AddNamespace("wp", "http://schemas.openxmlformats.org/
drawingml/2006/wordprocessingDrawing");
nmNamespaceMgr.AddNamespace("w10", "urn:schemas-microsoft-com:office:word");
nmNamespaceMgr.AddNamespace("w", "http://schemas.openxmlformats.org/
wordprocessingml/2006/main");
nmNamespaceMgr.AddNamespace("ds", "http://schemas.openxmlformats.org/
officeDocument/2006/customXml");
nmNamespaceMgr.AddNamespace("wne", "http://schemas.microsoft.com/
office/word/2006/wordml");
nmNamespaceMgr.AddNamespace("vt", "http://schemas.openxmlformats.org/
officeDocument/2006/docPropsVTypes");
nmNamespaceMgr.AddNamespace("", "http://schemas.openxmlformats.org/
officeDocument/2006/extended-properties");
/* These namespaces are not required however can be added if required at a later stage.
nsNamespaceMgr.AddNamespace("o12", "http://schemas.microsoft.com/
office/2004/7/core");
nsNamespaceMgr.AddNamespace("m", "http://schemas.microsoft.com/
office/omml/2004/12/core");
nsNamespaceMgr.AddNamespace("wp", "http://schemas.openxmlformats.org/
drawingml/2006/3/wordprocessingDrawing");
nsNamespaceMgr.AddNamespace("a", "http://schemas.openxmlformats.org/
drawingml/2006/3/main");
nsNamespaceMgr.AddNamespace("pic", "http://schemas.openxmlformats.org/
drawingml/2006/3/picture");
*/
return nmNamespaceMgr;
}

Create line items
The document template contains a table for line items. There is only one row of data for line items consisting of placeholder text in each cell. Now, programmatically find the row containing the placeholder string by looping through all the tables in the document.
// Looop thru all the rows in all tables until you find what you are looking for
foreach (XmlNode xnNode in xmlMainXMLDoc.SelectNodes("//w:body/w:tbl/w:tr", nsmgr))
{
// check if the current node is what you are after
if (xnNode.InnerText == "InvoiceLinePlaceholderText")
{
// if yes, Add line items to the document by passing the placeholder row node xnNode.
}
}
Note: Looping through each table is a work around for not having the ability to assign IDs to tables in Word 2007. This process is a bit expensive but not critical when you don't have a huge document.
Let's assume that we have loaded the data for invoice lines in a variable called xnRow.
Add invoice line items to the document by manipulating the data in the document.
//replace the existing text with line item data
xnNode.SelectNodes("w:tc/w:p/w:r/w:t", nmNamespaceMgr).Item(0).InnerText = xnRow.SelectSingleNode("@InvoiceLineDescription").InnerText;
xnNode.SelectNodes("w:tc/w:p/w:r/w:t", nmNamespaceMgr).Item(1).InnerText = xnRow.SelectSingleNode("@Amount").InnerText;
Note: For clarity purpose I haven't included that code that creates a copy of the placeholder node, if you have more than one line item. Make sure you do that. Loop through all line items and use the copy of the placeholder node and append it to the document.
Save the document.xml file
// Save the changes made to the xml document.
xmlMainXMLDoc.Save(ppDocPkgPart.GetStream(FileMode.Create, FileAccess.Write));

Content controls and custom XML
Use the custom XML files to manage the data in content controls. The custom XML files, if any, can be found under customXML folder of the document structure. Accessing these custom XML files is similar to that of any other document as explained above.
Let's assume that we have loaded the custom XML in a variable called xmlCustomXMLDoc of type XmlDocument. Replace the content in custom XML file with the actual data retrieved from the GetInvoiceReport() method.
// Get the invoice report xml and replace it with the current custom xml
XmlNode xnReport = GetInvoiceReport();
xmlCustomXMLDoc.SelectSingleNode("root").InnerText = "";
xmlCustomXMLDoc.AppendChild
(xmlCustomXMLDoc.OwnerDocument.ImportNode(xnReport, true));

Save the custom XML document as below
// Save the changes made to the xml document.

xmlCustomXMLDoc.Save(ppDocPkgPart.GetStream(FileMode.Create, FileAccess.Write));

Note: Word 2007 is inconsistent while mapping the content controls to custom XML files. For example, sometimes Word 2007 maps the content controls to /CustomXML/item2.xml file instead of /CustomXML/item1.xml. The work around is to use datastoreItem id of the custom XML to find the appropriate file. The datastoreitem id remains constant irrespective of the custom XML filename. I'll write more on this in another post.