When associating workflows with content types or lists a workflow status field is automatically generated and attached to the target list and default view. Doing this programmatically, for example by a FeatureReceiver, it might happen that status fields are added while creating a workflow association, but will not be removed in case of buggy code.

To cleanup the application you need to call a method like below:

RemoveSiteContentTypeAssociation(site, "My workflow title");

Site content types are mighty SharePoint elements. They can be inherited to child content types und used in lists. When you attach a workflow to a content type a lot of children and list might be influenced. So cleaning up your site collection can be tricky and time consuming.

The following method does the job. It crawls through your site collection finds all target workflow associations in webs, subwebs, content types and lists and finale removes all workflow status fields from the lists and the associations of course. Result: your workflow is completely removed from the site collection.

If you suggest a better method let me know.

public static void RemoveSiteContentTypeAssociation(SPSite site, string associationName)
{
    SPWeb rootWeb = site.RootWeb;
    SPWorkflowAssociation association = null;
    Console.WriteLine("Removing site contenttype workflow association '{0}'.", associationName);

    // Remove all site content type workflow associations
    foreach (SPContentType ctype in rootWeb.ContentTypes)
    {
        // Remove site content type workflow association
        association = ctype.WorkflowAssociations.GetAssociationByName(associationName, rootWeb.Locale);
        if (association != null) ctype.RemoveWorkflowAssociation(association);
    }

    // Remove list content type workflow associations
    foreach (SPWeb web in site.AllWebs)
    {
        // Since we plan to modify some lists later we can not use the standard web.Lists collection
        System.Collections.Generic.List<Guid> lists = new System.Collections.Generic.List<Guid>();
        foreach (SPList list in web.Lists) lists.Add(list.ID);

        // Check all lists
        foreach (Guid listId in lists)
        {
            // Get list
            SPList list = web.Lists[listId];

            // Remove all matching list content type associations
            foreach (SPContentType ctype in list.ContentTypes)
            {
                // Remove list content type workflow association
                association = ctype.WorkflowAssociations.GetAssociationByName(associationName, web.Locale);
                if (association != null) ctype.RemoveWorkflowAssociation(association);
            }

            // Find all workflow status fields in the list
            System.Collections.Generic.List<Guid> fields = new System.Collections.Generic.List<Guid>();
            foreach (SPField field in list.Fields)
            {
                // Check field and save Guid on match
                if (field.Type == SPFieldType.WorkflowStatus && field.Title == associationName) fields.Add(field.Id);
            }

            // Remove the fields from the list
            foreach (Guid fieldId in fields)
            {
                SPField f = list.Fields[fieldId];   // Get the status field
                f.ReadOnlyField = false;            // Flag read/write
                f.Update(true);                     // Update first otherwise the field cannot be deleted
                f.Delete();                         // Now delete
            }

            // Save modified list in database
            list.Update();
        }
        web.Dispose();
    }
}

The stylesheet expects culture dependend formatted InfoPath data where necessary. Normally date, time and number fields are culture dependend. Part2 shows how to transform InfoPath data into culture formatted InfoPath data. The xslt stylesheet InfoPathFormat.xslt calls the function xdFormatting:formatString($value, $type, $options) to output formatted values.

The formatString function is written in C# and passed to the xslt processor as an xslt extension object. I thought it would be good idea to to post about the formatString function separately, because it is also a key function which might be useful in other contexts. Please refer to Implement InfoPath formatString function for customized form data conversions to get a C# listing and see how to use xslt extensions objects.

The final step

Now since all key modules are explained and available it is time to combine them by packing them into the class MyLib.InfoPath.WordConverter. Below please find the C# listing.

I use the WordConverter inside an InfoPath form. I added a button control to the form. When clicked, the event handler first checks whether a pdf file is attached to the form. It is assumed that a pdf file is a manually signed document. If not, a word document is created and attached.

Example on how to use the WordConverter

public void btnCreateContract_Clicked(object sender, ClickedEventArgs e)
{
    // Get navigators
    XPathNavigator navRoot = this.MainDataSource.CreateNavigator();
    XPathNavigator navContract = navRoot.SelectSingleNode("/ns1:contract/ns1:file", this.NamespaceManager);

    // Create word document only, if no signed contract already attached.
    if (FileAttachment.IsPdf(navContract))
    {
        // Pdf attachment already exists
    }
    else
    {
        // Field is either empty or contains an unsigned document
        string viewPath = "view1.xsl";        // The view1 contains all the field formatting
        string dotxPath = "contract.dotx";    // Word template for contract
        string docxFilename = "contract.docx";    // Filename of the resulting word document

        using (Stream viewStream = this.Template.OpenFileFromPackage(viewPath))
        {
            using (Stream dotxStream = this.Template.OpenFileFromPackage(dotxPath))
            {
                FileAttachment.DeleteNillableAttribute(navContract);
                string wordAttachment = WordConverter.CreateWordDocument(navRoot, viewStream, dotxStream, docxFilename);
                navContract.SetValue(wordAttachment);
            }
        }
    }
}

Conclusion

The intension of this series of 3 posts was to show which steps are necessary to convert InfoPath form data to a rich Word document in cases where an electronical form is not useful, for example where signable paper documents are needed.

To keep things easy the Word document is based on a Word template with an embedded xml structure. The structure, which is actually a xml schema, is used by both the Word template and the InfoPath template. The default InfoPath view contains all the culture dependend formatting information to create the final Word document. In my case, the final document is programmatically attached to the InfoPath form and stored in a SharePoint form library. Now I can query form data, associate workflows and benefit from a convenient document management.

MyLib.InfoPath.WordConverter

using System.IO;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;
using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;

namespace MyLib.InfoPath
{
    public static class WordConverter
    {
        /**************/
        /* Properties */
        /**************/

        public static string InfoPath2WordStyleSheet { get { return GetFullResourceName("InfoPath2Word.xslt"); } }
        public static string InfoPathFormatStyleSheet { get { return GetFullResourceName("InfoPathFormat.xslt"); } }

        /**********************/
        /* CreateWordDocument */
        /**********************/

        /// <summary>
        /// Create a Word 2007 document from a Word template containing customXml tags
        /// </summary>
        /// <param name="infoPathForm">InfoPath form</param>
        /// <param name="viewStream">An InfoPath view (xsl-file), which contains all field formatting templates</param>
        /// <param name="dotxStream">The word template in which the data are to be inserted</param>
        /// <param name="docxFilename">Filename of the resulting word document</param>
        /// <returns>a base64 string which contains the InfoPath attachment encoded word document</returns>
        public static string CreateWordDocument(XPathNavigator infoPathForm, Stream viewStream, Stream dotxStream, string docxFilename)
        {
            // Create a new word document from word template
            using (MemoryStream docxStream = new MemoryStream())
            {
                // Copy template
                CopyStream(dotxStream, docxStream);

                // Open template, convert it to a document and merge document wizh InfoPath form data
                using (WordprocessingDocument docx = WordprocessingDocument.Open(docxStream, true))
                {
                    // Change type from template to document
                    docx.ChangeDocumentType(WordprocessingDocumentType.Document);

                    // Fill template by formatted InfoPath form data
                    FillDocument(docx, FormatInfoPathForm(infoPathForm, viewStream));

                    // Save all
                    docx.Package.Flush();
                }

                // Return base64 encoded string of the word document
                docxStream.Seek(0, SeekOrigin.Begin);
                return FileAttachment.ToBase64String(docxFilename, docxStream);
            }
        }

        /******************/
        /* Private methods */
        /******************/

        private static string GetFullResourceName(string resourceName)
        {
            string [] names = Assembly.GetExecutingAssembly().GetManifestResourceNames();
            foreach (string name in Assembly.GetExecutingAssembly().GetManifestResourceNames())
            {
                if (name.EndsWith(resourceName)) return name;
            }
            throw new FileNotFoundException("Resource file not found", resourceName);
        }
        private static void CopyStream(Stream input, Stream output)
        {
            int bufsize = 1024;
            byte[] buffer = new byte[bufsize];
            int bytes;

            while ((bytes = input.Read(buffer, 0, bufsize)) > 0) output.Write(buffer, 0, bytes);
            output.Seek(0, SeekOrigin.Begin);
        }
        private static void FillDocument(WordprocessingDocument docx, XmlDocument xml)
        {
            // Get document.xml from the docx package
            using (Stream streamDocument = docx.MainDocumentPart.GetStream(FileMode.Open, FileAccess.ReadWrite))
            {
                // Create and load a new transform object
                XslCompiledTransform xslt = NewTransformFromResource(InfoPath2WordStyleSheet);

                // Pass wordTemplate parameter to stylesheet
                XsltArgumentList xArgs = new XsltArgumentList();
                xArgs.AddParam("wordTemplate", "", XmlDocumentFromStream(streamDocument));

                // Transform infopath data to word document
                streamDocument.Seek(0, SeekOrigin.Begin);
                xslt.Transform(xml, xArgs, streamDocument);

                // Save
                docx.MainDocumentPart.Document.Save();
            }
        }
        private static XmlDocument FormatInfoPathForm(XPathNavigator infoPathForm, Stream viewStream)
        {
            using (MemoryStream strFormattedInfoPathForm = new MemoryStream())
            {
                // Create and load transform object
                XslCompiledTransform xslFormatter = NewTransformFromResource(InfoPathFormatStyleSheet, false, false, true);

                // Create transformation argument list
                XsltArgumentList xArgs = new XsltArgumentList();
                MyLib.Xslt.Formatting xo = new MyLib.Xslt.Formatting();
                xArgs.AddExtensionObject(xo.NamespaceUri, xo);
                XmlDocument xView = new XmlDocument();
                xView.Load(viewStream);
                xArgs.AddParam("view", "", xView);

                // Transform InfoPath form to a form with formatted values
                xslFormatter.Transform(infoPathForm, xArgs, strFormattedInfoPathForm);

                // Output formatted form
                strFormattedInfoPathForm.Seek(0, SeekOrigin.Begin);
                XmlDocument result = new XmlDocument();
                result.Load(strFormattedInfoPathForm);
                return result;
            }
        }
        private static XmlDocument XmlDocumentFromStream(Stream inStream)
        {
            XmlDocument xDoc = new XmlDocument();
            xDoc.Load(inStream);
            return xDoc;
        }
        private static XslCompiledTransform NewTransformFromResource(string stylesheetResource)
        {
            return NewTransformFromResource(stylesheetResource, false, null, null);
        }

       
        private static XslCompiledTransform NewTransformFromResource(string stylesheetResource, bool enableDebug)
        {
            return NewTransformFromResource(stylesheetResource, enableDebug, null, null);
        }
        private static XslCompiledTransform NewTransformFromResource(string stylesheetResource, bool enableDebug, bool enableDocumentFunction, bool enableScript)
        {
            return NewTransformFromResource(stylesheetResource, enableDebug, new XsltSettings(enableDocumentFunction, enableScript), null);
        }
        private static XslCompiledTransform NewTransformFromResource(string stylesheetResource, bool enableDebug, XsltSettings settings, XmlResolver resolver)
        {
            using (Stream strStylesheet = Assembly.GetExecutingAssembly().GetManifestResourceStream(stylesheetResource))
            {
                XmlTextReader xsltReader = new XmlTextReader(strStylesheet);
                XslCompiledTransform xslt = new XslCompiledTransform(enableDebug);
                xslt.Load(xsltReader, settings, resolver);
                return xslt;
            }
        }
        private static void Load(XslCompiledTransform xsltTransform, Stream xsltStream)
        {
            // Get xslt stream reader
            XmlTextReader xsltReader = new XmlTextReader(xsltStream);
            xsltTransform.Load(xsltReader);
        }
        private static void Transform(XslCompiledTransform xsltTransform, Stream xmlInStream, Stream xmlOutStream)
        {
            // Get xml stream reader
            XmlTextReader xmlReader = new XmlTextReader(xmlInStream);

            // Create stream writer
            XmlTextWriter xmlWriter = new XmlTextWriter(xmlOutStream, Encoding.UTF8);

            // Transform to new stylesheet
            xsltTransform.Transform(xmlReader, xmlWriter);
        }
    }
}

If you create your own xslt stylesheet or if you use an existing InfoPath view to programmatically transform your form data, you normally will need to format multiline strings, numbers, date and time values. The InfoPath object model offers the method Application.FormatString which can be used for all formatting. Also the InfoPath views try to call the method formatString during transformation. Example:

InfoPath view snippet

<xsl:choose>
    <xsl:when test="function-available('xdFormatting:formatString')">
        <xsl:value-of select="xdFormatting:formatString(fp:address,&quot;string&quot;,&quot;plainMultiline&quot;)" disable-output-escaping="yes"/>
    </xsl:when>
    <xsl:otherwise>
             <xsl:value-of select="fp:address" disable-output-escaping="yes"/>
    </xsl:otherwise>
</xsl:choose>

Problem

The FormatString method is not available in browser-enabled forms. Browser-enabled forms use a different object model.

As you can see from the snippet above the xslt processor tries to call the formatString function which is not defined as member of the processor. It is defined as member of an xslt extension object which is passed as an input parameter.

Task

Write a C# class with the method formatString. The method must be compatible to FormatString method which is defined by the InfoPath object model. See Application.FormatString Method for more information. Better said the method “should be” compatible, if you want to use stylesheets (views) which are designed with the InfoPath editor.

Solution

Below please find the listing MyLib.Xslt.Formatting which realized the xslt extension object. To pass the extension object to the xslt processor: 

 // Create transformation argument list
 XsltArgumentList xArgs = new XsltArgumentList();
 MyLib.Xslt.Formatting xo = new MyLib.Xslt.Formatting();
 xArgs.AddExtensionObject(xo.NamespaceUri, xo);

Conclusion

If you programmatically tranform InfoPath form data you can use an xslt stylesheet together with an an extension object. The extension object contains the method formatString which is can also called by InfoPath designed stylesheets (views). The C# class listing MyLib.Xslt.Formatting below realizes the extension object.

Note: The class below does not offer full 100% of the functionality. Missing parts are commented and will be added later. Sorry, guys, you forced me to publish this article before I could finish all. Feel free to publish a completed or even better solution and let me know.

MyLib.Xslt.Formatting

using System;
using System.Collections.Specialized;
using System.Globalization;
using System.Reflection;
using System.Threading;
using System.Xml.XPath;
namespace MyLib.Xslt
{
    /// <summary>
    /// This class contains xslt extension methods
    /// </summary>
    public class Formatting
    {
        /**************/
        /* Properties */
        /**************/

        public string NamespaceUri
        {
            get { return "<a href="http://schemas.microsoft.com/office/infopath/2003/xslt/formatting">http://schemas.microsoft.com/office/infopath/2003/xslt/formatting</a>"; }
        }

        /******************/
        /* Public methods */
        /******************/

        /// <summary>
        /// Formats the specified string or XML node according to the specified category and options parameters.
        /// This extension method is used by browser-enable InfoPath forms
        /// </summary>
        /// <param name="input">The string value or XML node to be formatted.</param>
        /// <param name="category">The string value that specifies the category used for formatting. Values include number, percentage, currency, date, time, and datetime.</param>
        /// <param name="options">The string value that specifies the options used for formatting. Takes the form of a case-sensitive string in the format "optionName:value".</param>
        /// <returns>the formatted string</returns>
        /// <see cref="http://msdn.microsoft.com/en-us/library/bb229767.aspx"/>
        public string formatString(object input, string category, string options)
        {
            // Get expected type of MS.Internal.Xml.XPath.XPathArrayIterator
            Type t = input.GetType();

            // Move to first node and examine its value
            if ((bool)t.InvokeMember("MoveNext", BindingFlags.InvokeMethod, null, input, null))
            {
                XPathNavigator xNav = (XPathNavigator)t.InvokeMember("Current", BindingFlags.GetProperty, null, input, null);
                string val = xNav.Value;
                NameValueCollection nvcOptions = getOptions(options);
                switch (category)
                {
                    case "number":
                        return fmtNumber(val, nvcOptions);
                    case "percentage":
                        return fmtPercentage(val, nvcOptions);
                    case "currency":
                        return fmtCurrency(val, nvcOptions);
                    case "date":
                        return fmtDate(val, nvcOptions);
                    case "time":
                        return fmtTime(val, nvcOptions);
                    case "datetime":
                        return fmtDateTime(val, nvcOptions);
                    case "string":
                        return fmtString(val, nvcOptions);
                    default:
                        throw new NotImplementedException();
                }
            }
            else return string.Empty;
        }

        /*******************/
        /* Private methods */
        /*******************/

        /// <summary>
        /// Format a numerical value.
        /// </summary>
        /// <param name="value">Value to be formatted</param>
        /// <param name="options">Valid options include locale, numDigits, leadingZero, grouping, decimalSep, thousandSep, and negativeOrder</param>
        /// <returns>the formatted value</returns>
        private string fmtNumber(string value, NameValueCollection options)
        {
            // Set culture
            string option = options["locale"];
            CultureInfo culture = (option == null) ? Thread.CurrentThread.CurrentUICulture : CultureInfo.GetCultureInfo(int.Parse(option));

            // Get number format provider
            NumberFormatInfo nfi = culture.NumberFormat.Clone() as NumberFormatInfo;

            // Set number of decimal digits
            option = options["numDigits"];
            if (option != null) nfi.NumberDecimalDigits = int.Parse(option);

            //// Specifies whether to use leading zeros in decimal fields.
            //// Specify 0 to indicate no leading zeros and 1 to indicate leading zeros.
            //// Defaults to the corresponding value in regional settings if not specified.
            //int leadingZero = 0;

            // Specifies the size of each group of digits to the left of the decimal.
            // Values in the range 0–9 and value 32 are valid. Value 32 indicates that the grouping is three digits, then two digits thereafter.
            // Defaults to the corresponding value in regional settings if not specified.
            option = options["grouping"];
            if (option != null)
            {
                int groupSize = int.Parse(option);
                if (groupSize < 10) nfi.NumberGroupSizes = new int[] {groupSize};
                else nfi.NumberGroupSizes = new int[] {3, 2};
            }

            // Set the decimal separator string
            option = options["decimalSep"];
            if (option != null) nfi.NumberDecimalSeparator = option;

            // Set the thousands separator string.
            option = options["thousandSep"];
            if (option != null) nfi.NumberGroupSeparator = option;

            //// Specifies the negative number mode. Defaults to the corresponding value in regional settings if not specified.
            //int negativeOrder = 1;

            return string.Format(nfi, "{0:N}", double.Parse(value, new CultureInfo("en-US")));
        }
        /// <summary>
        /// Format percentage value.
        /// </summary>
        /// <param name="val"></param>
        /// <param name="nvcOptions">Valid options for this category include locale, numDigits, leadingZero, grouping, decimalSep, thousandSep, and negativeOrder.</param>
        /// <returns></returns>
        private string fmtPercentage(string value, NameValueCollection options)
        {
            // Set culture
            string option = options["locale"];
            CultureInfo culture = (option == null) ? Thread.CurrentThread.CurrentUICulture : CultureInfo.GetCultureInfo(int.Parse(option));

            // Get number format provider
            NumberFormatInfo nfi = culture.NumberFormat.Clone() as NumberFormatInfo;

            // Set number of decimal digits
            option = options["numDigits"];
            if (option != null) nfi.PercentDecimalDigits = int.Parse(option);

            //// Specifies whether to use leading zeros in decimal fields.
            //// Specify 0 to indicate no leading zeros and 1 to indicate leading zeros.
            //// Defaults to the corresponding value in regional settings if not specified.
            //int leadingZero = 0;

            // Specifies the size of each group of digits to the left of the decimal.
            // Values in the range 0–9 and value 32 are valid. Value 32 indicates that the grouping is three digits, then two digits thereafter.
            // Defaults to the corresponding value in regional settings if not specified.
            option = options["grouping"];
            if (option != null)
            {
                int groupSize = int.Parse(option);
                if (groupSize < 10) nfi.PercentGroupSizes = new int[] { groupSize };
                else nfi.NumberGroupSizes = new int[] { 3, 2 };
            }

            // Set the decimal separator string
            option = options["decimalSep"];
            if (option != null) nfi.PercentDecimalSeparator = option;

            // Set the thousands separator string.
            option = options["thousandSep"];
            if (option != null) nfi.PercentGroupSeparator = option;

            //// Specifies the negative number mode. Defaults to the corresponding value in regional settings if not specified.
            //int negativeOrder = 1;

            return string.Format(nfi, "{0:P}", double.Parse(value, new CultureInfo("en-US")));
        }
        /// <summary>
        /// Format currency value
        /// </summary>
        /// <param name="val"></param>
        /// <param name="nvcOptions">Valid options for this category include locale, numDigits, leadingZero, grouping, decimalSep, thousandSep, negativeOrder, positiveOrder, and currencyLocale.</param>
        /// <returns></returns>
        private string fmtCurrency(string value, NameValueCollection options)
        {
            throw new NotImplementedException();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="val"></param>
        /// <param name="nvcOptions">Valid options for this category include locale, dateFormat, useAltCalendar, and useEnglishStringsAlways.</param>
        /// <returns></returns>
        private string fmtDate(string value, NameValueCollection options)
        {
            // Set culture
            string option = options["locale"];
            CultureInfo culture = (option == null) ? Thread.CurrentThread.CurrentUICulture : CultureInfo.GetCultureInfo(int.Parse(option));

            // Get date time format provider
            DateTimeFormatInfo dtfi = culture.DateTimeFormat.Clone() as DateTimeFormatInfo;
            string baseFormat = "{{0:{0}}}";

            // dateFormat: Specifies a format picture string that is used to form the date string.
            // The values Short Date, Long Date, Year Month, and none may also be used to indicate
            // short date format, long date format, year month format, and no format, respectively.
            // Short Date, Long Date, and Year Month are the default formats provided by the
            // operating system's regional and language settings.
            string fmt = "{0}";
            switch (options["dateFormat"])
            {
                case "Short Date":
                    fmt = string.Format(baseFormat, dtfi.ShortDatePattern);
                    break;

                case "Long Date":
                    fmt = string.Format(baseFormat, dtfi.LongDatePattern);
                    break;

                case "Year Month":
                    fmt = string.Format(baseFormat, dtfi.YearMonthPattern);
                    break;

                case "none":
                    fmt = "{0}";
                    break;

                default:
                    fmt = string.Format(baseFormat, dtfi.ShortDatePattern);
                    break;
            }

            // useAltCalendar: Specifies whether to use an alternate calendar for date formatting.
            // Specify 0 to use the normal calendar and 1 to use the alternate calendar.
            // Defaults to 0 if not specified.

            // useEnglishStringsAlways: Specifies whether to always use English strings for date formatting.
            // Specify 0 to use the language specified by locale and 1 to always use English.
            // Defaults to 0 if not specified.

            // Output result
            return string.Format(dtfi, fmt, DateTime.Parse(value));
        }
        /// <summary>
        /// Format time values.
        /// </summary>
        /// <param name="value">Value to be formatted</param>
        /// <param name="options">Valid options for this category include locale, timeFormat, and noSeconds.</param>
        /// <returns>the formatted value</returns>
        private string fmtTime(string value, NameValueCollection options)
        {
            // Set culture
            string option = options["locale"];
            CultureInfo culture = (option == null) ? Thread.CurrentThread.CurrentUICulture : CultureInfo.GetCultureInfo(int.Parse(option));

            // Get date time format provider
            DateTimeFormatInfo dtfi = culture.DateTimeFormat.Clone() as DateTimeFormatInfo;
            string baseFormat = "{{0:{0}}}";

            // noSeconds: Specifies whether to not use seconds.
            // Specify 0 to use seconds and 1 to not use seconds. Defaults to 0 if not specified.
            option = options["noSeconds"];
            string fmt = string.Format(baseFormat, dtfi.LongTimePattern);
            if (option != null && int.Parse(option) == 1) fmt = string.Format(baseFormat, dtfi.ShortTimePattern);

            // timeFormat: Specifies a format string that is used to form the time string.
            // The value none may also be used to indicate no format.
            // Defaults to the time format in regional settings if not specified.
            option = options["timeFormat"];
            if (option != null) fmt = string.Format(baseFormat, option);

            // Output result
            return string.Format(dtfi, fmt, DateTime.Parse(value));
        }
        /// <summary>
        /// Format DateTime values
        /// </summary>
        /// <param name="value">Value to be formatted</param>
        /// <param name="nvcOptions">Valid options for this category include locale, dateFormat, timeFormat, noSeconds, useAltCalendar, and useEnglishStringAlways.</param>
        /// <returns></returns>
        private string fmtDateTime(string val, NameValueCollection nvcOptions)
        {
            throw new NotImplementedException();
        }
        /// <summary>
        /// Formats a string
        /// </summary>
        /// <param name="value">Value to be formatted</param>
        /// <param name="options">Valid options for this category include plainMultiline</param>
        /// <returns>the formatted string</returns>
        private string fmtString(string value, NameValueCollection options)
        {
            string option = options["plainMultiline"];
            if (option != null)
            {
                return (value == string.Empty) ? "<br/>" : value.Replace("\r\n","<br/>");
            }

            return value;
        }
        /// <summary>
        /// Returns the format options as a name value collection
        /// </summary>
        private NameValueCollection getOptions(string options)
        {
            NameValueCollection nvc = new NameValueCollection();
            string[] nameValues = options.Split(new char[] { ':', ';' }, StringSplitOptions.RemoveEmptyEntries);
            for (int i = 0; i < nameValues.Length; i++)
            {
                string name = nameValues[i++];
                string val = (i < nameValues.Length) ? nameValues[i] : string.Empty;
                nvc.Add(name, val);
            }
            return nvc;
        }

    }
}

Continuing with the second step

If your InfoPath form contains not only simple text but also formatted numbers, date and time values it is necessary to preformat the raw data. InfoPath stores for example a date in this way “2010-02-13″ instead of “02/13/2010″ or “13.2.2010″ or any other culture dependent date format. Similarly numbers, currencies or percentage values are stored as integer or real values without any formatting.

When you design a InfoPath view you also define all formatting information by setting the properties of all data fields. Because the format information is already stored in a view, it is natural to use this by further processes again.

Remember an InfoPath solution file (*.xsn) is a file cabinet. Simply rename the solution file to *.cab to access all the files inside the cabinet. The InfoPath views are xslt stylesheets with default filenames of view1.xsl, view2.xsl and so on. These stylesheets present the form data to the user in that way you have designed it using the InfoPath designer.

Task

Create an xslt stylesheet to transform InfoPath form data to itself. Keep the structure but format the data. Use an InfoPath view as an input parameter to get all format information of the individual fields and repeated elements.

Solution

Below please find the listing of the stylesheet InfoPathFormat.xslt which fullfills the task. The stylesheet calls the function formatString(), which is defined by an transform extension object. The extension object is written in C#  and will be posted next.

Conclusion

The stylesheet InfoPathFormat.xslt formats InfoPath form data by using a view file as input parameter. The resulting xml file together with a Word 2007 template will be used by InfoPath2Word.xslt, which is presented in Part 1 of this blog, to perform the final transformation to Word 2007.

InfoPathFormat.xslt

<?xml version="1.0" encoding="utf-8"?>
<!--
This stylesheet is used to format InfoPath form data, whereby the formatting
information is taken from a view stylesheet, typically from view1.xsl of the
InfoPath cabinet.
-->
<xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:xd="http://schemas.microsoft.com/office/infopath/2003"
  xmlns:xdFormatting="http://schemas.microsoft.com/office/infopath/2003/xslt/formatting"
  xmlns:msxsl="urn:schemas-microsoft-com:xslt"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:scrpt="http://tempuri.org/InfoPath/Scripts"
  exclude-result-prefixes="msxsl"
>
  <!-- ======= -->
  <!-- Setting -->
  <!-- ======= -->

  <xsl:output method="xml" indent="yes" encoding="utf-8" />

  <!-- ========== -->
  <!-- Parameters -->
  <!-- ========== -->

  <!--
  The input parameters are preset for debugging purpose. For runtime
  use only one parameter either viewLocation or view.
  -->

  <xsl:param name="viewLocation" select="'Sample/view1.xsl'" />
  <xsl:param name="view" select="document($viewLocation)" />

  <!-- ========= -->
  <!-- Variables -->
  <!-- ========= -->

  <!-- Contains a list of data bindings -->
  <xsl:variable name="bindings" select="$view//*[@xd:binding]" />

  <!-- ======= -->
  <!-- Scripts -->
  <!-- ======= -->
 
  <!-- Embedded script to implement the ends-with function -->
  <msxsl:script language ="JScript" implements-prefix="scrpt">
    function EndsWith(str, iterator) {
    var s1 = str.Value;
    iterator.MoveNext();
    var s2 = iterator.Current.Value
    return s1.EndsWith(s2);
    }
  </msxsl:script>

  <!-- ==== -->
  <!-- Root -->
  <!-- ==== -->
 
  <!-- Entry point -->
  <xsl:template match="/">
    <xsl:copy-of select="processing-instruction()" />
    <xsl:apply-templates select="*" />
  </xsl:template>

  <!-- Nested elements -->
  <xsl:template match="*[*]">
    <xsl:copy>
      <xsl:apply-templates select="@* | *" />
    </xsl:copy>
  </xsl:template>

  <!-- Final elements -->
  <xsl:template match="*">
    <xsl:copy>
      <xsl:apply-templates select="@* | text()" />
    </xsl:copy>
  </xsl:template>

  <!-- Attributes -->
  <xsl:template match="@*">
    <xsl:variable name="_binding">
      <xsl:apply-templates select="." mode="get-binding" />
    </xsl:variable>
    <xsl:variable name="binding" select="msxsl:node-set($_binding)" />
    <xsl:attribute name="{name()}">
      <xsl:choose>
        <xsl:when test="$binding">
          <xsl:apply-templates select="$binding/*">
            <xsl:with-param name="value" select="." />
          </xsl:apply-templates>
        </xsl:when>
        <xsl:otherwise>
          <xsl:value-of select="." />
        </xsl:otherwise>
      </xsl:choose>
    </xsl:attribute>
  </xsl:template>

  <!-- Text nodes -->
  <xsl:template match="text()">
    <xsl:variable name="_binding">
      <xsl:apply-templates select="." mode="get-binding" />
    </xsl:variable>
    <xsl:variable name="binding" select="msxsl:node-set($_binding)" />
    <xsl:choose>
      <xsl:when test="$binding">
        <xsl:apply-templates select="$binding/*">
          <xsl:with-param name="value" select="." />
        </xsl:apply-templates>
      </xsl:when>
      <xsl:otherwise>
        <xsl:copy />
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <!-- FileAttachment output -->
  <xsl:template match="span[@xd:xctname='FileAttachment']">
    <xsl:param name="value" />
    <xsl:value-of select="$value" />
  </xsl:template>

  <!-- Date and time output -->
  <xsl:template match="span[@xd:xctname='PlainText' or @xd:xctname='DTPicker_DTText'][@xd:datafmt]" priority="2">
    <xsl:param name="value" />
    <xsl:apply-templates select="@xd:datafmt">
      <xsl:with-param name="value" select="$value" />
    </xsl:apply-templates>
  </xsl:template>

  <!-- Plaintext output -->
  <xsl:template match="span[@xd:xctname='PlainText']" priority="1">
    <xsl:param name="value" />
    <xsl:value-of select="$value" />
  </xsl:template>

  <!-- Checkbox output -->
  <xsl:template match="input[@xd:xctname='CheckBox']">
    <xsl:param name="value" />
    <xsl:choose>
      <xsl:when test="$value=@xd:onValue">
        <!-- Wingding 2 crossed square -->
        <xsl:text>T</xsl:text>
      </xsl:when>
      <xsl:otherwise>
        <!-- Windging 2 square -->
        <xsl:text>£</xsl:text>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>

  <!-- =========== -->
  <!-- @xd:datafmt -->
  <!-- =========== -->
 
  <!-- Formatted multiline output -->
  <xsl:template match="@xd:datafmt[.='&quot;string&quot;,&quot;plainMultiline&quot;'][function-available('xdFormatting:formatString')]">
    <xsl:param name="value" />
    <xsl:variable name="type" select="substring-before(substring-after(., '&quot;'), '&quot;,&quot;')" />
    <xsl:variable name="options" select="substring-before(substring-after(., '&quot;,&quot;'), '&quot;')" />
    <xsl:value-of select="xdFormatting:formatString($value, $type, $options)" disable-output-escaping="yes" />
  </xsl:template>

  <!-- Standard multiline output -->
  <xsl:template match="@xd:datafmt[.='&quot;string&quot;,&quot;plainMultiline&quot;']">
    <xsl:param name="value" />
    <xsl:value-of select="$value" disable-output-escaping="yes" />
  </xsl:template>

  <!-- Formatted output of number, percentage, currency, date and time values -->
  <xsl:template match="@xd:datafmt[function-available('xdFormatting:formatString')]">
    <xsl:param name="value" />
    <xsl:variable name="type" select="substring-before(substring-after(., '&quot;'), '&quot;,&quot;')" />
    <xsl:variable name="options" select="substring-before(substring-after(., '&quot;,&quot;'), '&quot;')" />
    <xsl:value-of select="xdFormatting:formatString($value, $type, $options)" />
  </xsl:template>

  <!-- Standard output -->
  <xsl:template match="@xd:datafmt">
    <xsl:param name="value" />
    <xsl:value-of select="$value" />
  </xsl:template>

  <!-- =========== -->
  <!-- get-binding -->
  <!-- =========== -->
 
  <xsl:template match="@*" mode="get-binding">
    <!-- Get absolute xpath expression of the current attribute -->
    <xsl:variable name="xpath">
      <xsl:apply-templates select="parent::*" mode="get-binding" />
      <xsl:text>/@</xsl:text>
      <xsl:value-of select="name()" />
    </xsl:variable>
    <!-- @xd:binding contains a relative xpath. $xpath contains the absolute path. -->
    <!-- Filter the first binding where the absolute path $xpath ends with the relative path @xd:binding. -->
    <xsl:copy-of select="$bindings[scrpt:EndsWith($xpath, @xd:binding)][1]"/>
  </xsl:template>

  <xsl:template match="text()" mode="get-binding">
    <!-- Get absolute xpath expression of the current element -->
    <xsl:variable name="xpath">
      <xsl:apply-templates select="parent::*" mode="get-binding" />
    </xsl:variable>
    <!-- @xd:binding contains a relative xpath. $xpath contains the absolute path. -->
    <!-- Filter the first binding where the absolute path $xpath ends with the relative path @xd:binding. -->
    <xsl:copy-of select="$bindings[scrpt:EndsWith($xpath, @xd:binding)][1]"/>
  </xsl:template>

  <xsl:template match="*" mode="get-binding">
    <!-- Output parent xpath terms first -->
    <xsl:apply-templates select="parent::*" mode="get-binding" />
    <!-- Output the current term of the xpath expression -->
    <xsl:text>/</xsl:text>
    <xsl:value-of select="name()" />
  </xsl:template>

</xsl:stylesheet>

Which is your workaround? In case you need for example a contract with your customer you would probably design a electronical form to collect the customer’s data and contract details and another form or document which contains the contract text and some space for manual signatures. Also very often you will transfer the data from the electronical form to your paper document manually.

Task

You need a tool which automatically transforms a InfoPath 2007 form into a Word 2007 document.

Possible Solutions

1. With InfoPath you can design a print view and send it to your printer. The disadvantage is that you will get a html output with all the difficulties of formatting, specially when your field sizes and text sizes are of variable lengths.
2. InfoPath 2003 SDK includes the “InfoPath to Word Wizard”. You can still use this tool for InfoPath 2007. The wizard helps to create a xsl stylesheet which can be uploaded to InfoPath as a print view for Word. When you print your form it is first transformed to Word and then output. The disadvantage: The transformation is still to html output only shown by Word. Again you need manual formatting for a final result.
3. Word 2007 implements the OpenXml standards which means you easily can create a document programmatically. Downloading the OpenXml SDK 2.0 gives you all the tools and libraries necessary. Disadvantage: Well, if you have not only one form to convert but many or if you have changing forms there are a lot of programming works and updates administration.
4. You may follow this block to see how you can merge InfoPath 2007 form data (.xml) and a Word 2007 template (.dotx) to a resulting Word 2007 document (.docx). Furthermore the final document will be attached to the InfoPath form itself to have both forms available the same time on your SharePoint. If you need to print and sign the document simply download it, print it, sign it, scan it and upload the signed version as a .pdf file to the InfoPath form again. A piece of C# code assures that your signed document is not lost.

Solution #4: Here we go

There are some milestones to achieve until you will have the final solution. The result will be a little C# class library with embedded resources which will be used by InfoPath. We need:

1. an xslt stylesheet to transform InfoPath 2007 form data into an OpenXml compatible xml file which can be loaded into a Word 2007 package. Remember Word 2007 is actually a zip archive. Rename a document to *.zip and discover what is inside.
2. an additional stylesheet to preformat the form data. This is necessary to provide number, percentage, date and time formatting prior to the Word transformation.
3. a little piece of C# which reads the Word template, examines the InfoPath solution for formatting purpose, retrieves the form data, creates the Word document and saves the result as an InfoPath file attachement.

Beginning with the first step

Below please find the xslt stylesheet which transforms InfoPath form data to Word document based on a Word template which is passed as a parameter. To test the stylesheet:

1. Create an InfoPath 2007 form
2. Fill the form with sample data and save it
3. Create a Word 2007 template (*.dotx)
4. Attach the form’s schema to the Word template
   1. Open the word template
   2. Select the developer tab (Maybe you need to enable it first)
   3. In the Xml section, select Schema
   4. Click Add Schema button
   5. Navigate to the sample form and select it. Click to the Open button
   6. Click OK to close Schema settings and OK to close the Templates and Add-ins windows
   7. Select Structure from the XML section in the ribbon to view the available elements that are defined by the schema.
5. Insert all data elements you need into your Word template.
6. Finish and save your Word template
7. Now rename template from *.dotx to *.dotx.zip
8. Copy the file word/document.xml from the zip archive. -> You got the input parameter for the stylesheet
9. Rename your template back to *.dotx
10. Launch Visual Studio 2005 or 2008
11. Load the InfoPath form data, the template document.xml and the stylesheet (see code below)
12. Use the stylesheet debugger to examine and debug it.

When transforming InfoPath to Word a resulting xml file is generated. You may use it to replace the orginal document.xml manually within the Word package (as shown above, steps 7-9).

The following posts will show how to do it programmatically.

Conclusion

The stylesheet InfoPath2Word.xslt listed below is used to convert InfoPath 2007 form data to Word 2007. A Word 2007 template is used as input parameter for the stylesheet. Both InfoPath and Word must be based on the same xml schema to successfully merge data and template to a new document.

InfoPath2Word.xslt

<?xml version="1.0" encoding="utf-8"?>
<!--
This stylesheet merges InfoPath 2007 form data with the appropriate
document.xml file of a Word 2007 document (docx) or template (dotx)
package.
The word document must have the same structure as the InfoPath
form data, which means that a data schema has to be added to the
Word document and data elements defined by the schema are
inserted into the document. You can achieve this by using the
developer tools of word. Inserting elements creates w:customXml
tags within the document which are used to synchronize with the
form data.
-->
<xsl:stylesheet
  version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
  xmlns:msxsl="urn:schemas-microsoft-com:xslt"
  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
  exclude-result-prefixes="msxsl"
>
  <!-- ======== -->
  <!-- Settings -->
  <!-- ======== -->
  <xsl:output method="xml" indent="yes" encoding="utf-8" standalone="yes" />
  <!-- ========== -->
  <!-- Parameters -->
  <!-- ========== -->
  <!--
  The input parameters are preset for debugging purpose. For runtime
  use only one parameter either wordTemplateLocation or wordTemplate
  -->
  <xsl:param name="wordTemplateLocation" select="'Sample/document.xml'" />
  <xsl:param name="wordTemplate" select="document($wordTemplateLocation)" />
  <!-- ==== -->
  <!-- Root -->
  <!-- ==== -->
  <!-- Passed InfoPath form data processing starts here -->
  <xsl:template match="/">
    <xsl:choose>
      <xsl:when test="$wordTemplate">
        <xsl:apply-templates select="$wordTemplate/*" mode="copy">
          <xsl:with-param name="data" select="." />
        </xsl:apply-templates>
      </xsl:when>
      <xsl:otherwise>
        <xsl:message terminate="yes">Parameter "wordTemplate" not passed</xsl:message>
      </xsl:otherwise>
    </xsl:choose>
  </xsl:template>
  <!-- ==== -->
  <!-- copy -->
  <!-- ==== -->
  <!-- General word elements output -->
  <xsl:template match="*" mode="copy">
    <xsl:param name="data" />
    <xsl:copy>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates select="*" mode="copy">
        <xsl:with-param name="data" select="$data" />
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  <!-- Document text output -->
  <xsl:template match="w:t" mode="copy">
    <xsl:copy-of select="." />
  </xsl:template>
  <!-- Repeated data elements output -->
  <xsl:template match="w:tr[w:customXml[w:tc]]" mode="copy">
    <xsl:param name="data" />
    <xsl:variable name="children" select="*" />
    <xsl:variable name="attrs" select="@*" />
    <xsl:for-each select="$data">
      <w:tr>
        <xsl:copy-of select="$attrs" />
        <xsl:apply-templates select="$children" mode="copy">
          <xsl:with-param name="data" select="." />
        </xsl:apply-templates>
      </w:tr>
    </xsl:for-each>
  </xsl:template>
  <!-- Simple empty customXml -->
  <xsl:template match="w:customXml[count(*)=0]" mode="copy">
    <xsl:param name="data" />
    <xsl:variable name="element" select="@w:element" />
    <xsl:copy>
      <xsl:copy-of select="@*" />
      <!--Inserting form data is done here -->
      <xsl:apply-templates select="$data/*[local-name()=$element]/text()" mode="data">
        <xsl:with-param name="word" select="." />
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  <!-- Basic customXml with some formatting, typically w:tc or w:p elements-->
  <xsl:template match="w:customXml[count(*)=1]" mode="copy">
    <xsl:param name="data" />
    <xsl:variable name="element" select="@w:element" />
    <xsl:copy>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates select="*" mode="insert">
        <xsl:with-param name="data" select="$data/*[local-name()=$element]" />
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  <!-- Nested, but not repeated customXml -->
  <xsl:template match="w:customXml[.//w:customXml]" mode="copy" priority="1">
    <xsl:param name="data" />
    <xsl:variable name="element" select="@w:element" />
    <xsl:copy>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates select="*" mode="copy">
        <xsl:with-param name="data" select="$data/*[local-name()=$element]" />
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  <!-- ====== -->
  <!-- insert -->
  <!-- ====== -->
  <xsl:template match="*" mode="insert">
    <xsl:param name="data" />
    <xsl:copy>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates select="*" mode="insert">
        <xsl:with-param name="data" select="$data" />
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  <xsl:template match="w:p[not(w:r)]" mode="insert">
    <xsl:param name="data" />
    <xsl:copy>
      <xsl:copy-of select="@*" />
      <xsl:apply-templates select="*" mode="insert">
        <xsl:with-param name="data" select="$data" />
      </xsl:apply-templates>
      <!-- Insert form data into paragraph element w:p -->
      <xsl:apply-templates select="$data/text()" mode="data">
        <xsl:with-param name="word" select="." />
      </xsl:apply-templates>
    </xsl:copy>
  </xsl:template>
  <!-- ==== -->
  <!-- data -->
  <!-- ==== -->
  <!-- Multiline form data -->
  <xsl:template match="text()[contains(., '&amp;#10;')]" mode="data">
    <xsl:param name="word" />
    <xsl:apply-templates select="msxsl:node-set(substring-before(., '&amp;#10;'))/text()" mode="data">
      <xsl:with-param name="word" select="$word" />
    </xsl:apply-templates>
    <xsl:apply-templates select="msxsl:node-set(substring-after(., '&amp;#10;'))/text()" mode="data">
      <xsl:with-param name="word" select="$word" />
      <xsl:with-param name="break" select="true()" />
    </xsl:apply-templates>
  </xsl:template>
  <!-- Single line form data -->
  <xsl:template match="text()" mode="data">
    <xsl:param name="word" />
    <xsl:param name="break" select="false()" />
    <w:r w:rsidRPr="{$word/ancestor::w:p/@w:rsidRPr}">
      <xsl:copy-of select="$word/ancestor::w:p/w:pPr/w:rPr"/>
      <xsl:if test="$break">
        <w:br />
      </xsl:if>
      <w:t>
        <xsl:value-of select="." />
      </w:t>
    </w:r>
  </xsl:template>
</xsl:stylesheet>

Other symptoms of doing something wrong: Either the “DC Launcher” service will not start or the web application on port 8082 is down. Unfortunatelly you can start both manually and all seems to be okay.

Reason

The Document Conversion Launcher service is already listing to port 8082. You may not have two listeners to the same port.

Workaround

I guess that the best practice will be to relocate the web application to another port. Simply create a new web application at the desired port (other than port 8082), detach the content database of the old web application and attach it at the new one.

Problem

After shutting down the old server the InfoPath forms of a form library were not accessible anymore, because the template was also shut down together with the server and there was no other copy in the network known by the InfoPath framework. Therefore InfoPath couldn’t show the form. So what to do?

An InfoPath form is a xml file having a couple of processing-instuctions in its header. Example:

<?xml version="1.0" encoding="UTF-8"?>
<?mso-infoPathSolution solutionVersion="1.0.0.121" productVersion="12.0.0" PIVersion="1.0.0.0" href="http://www.domain.de/FormServerTemplates/MyForm.xsn" name="urn:schemas-microsoft-com:office:infopath:MyForm:http---www-domain-de-MyForm" language="de" ?>
<?mso-application progid="InfoPath.Document" versionProgid="InfoPath.Document.2"?>
... form data go here ...

The processing instruction “mso-infoPathSolution” contains a href attribute which points to the form template. In my case the href points to the Forms Server. The form template must be accessible by InfoPath to open the form.

Task

Update the template references of all forms!

Solution

Since I do a lot of my SharePoint administration stuff  with batch files, I wrote the console application “UpdateIPFormTemplateLocation”.

Usage:  UpdateIPFormTemplateLocation.exe -web [web url]  -lib [library name] -loc [form template url]

Example: UpdateIPFormTemplateLocation.exe -web http://www.yourdomain.com/yourweb -lib yourlibname -loc http://www.anotherdomain.com/FormServerTemplates/MyForm.xsn

The complete C# source code is listed below. I guess it is self explaining.

Conclusion

The tool “UpdateIPFormTemplateLocation” (see source code below) updates the references of InfoPath forms to their template. It is useful after relocation of form libraries or template libraries.

Before running the tool you should check associated workflows. Workflows may be attached to the form library or the form’s content type and may be triggered by updating the forms. If you don’t want further actions by workflows while updating you need to disable the workflows before you start the tool. After all done renable the workflows again.

You may also slightly modify the source code to update any data fields of InfoPath forms. 

Hope it helps and feel free to improve my solution.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;
using System.Xml;
using Microsoft.SharePoint;
namespace UpdateIPFormTemplateLocation
{
    /// <summary>
    /// This tool updates all InfoPath forms of a form library after
    /// the library has been relocated to another server or web.
    /// The update adjusts the "href" attribute of the form's
    /// processing-instruction to new location of the form template.
    /// </summary>
    class Program
    {
        /// <summary>
        /// Thread sleep time [ms] after one form has been updated
        /// </summary>
        private static int _SleepTime = 5000;
        /// <summary>
        /// Main entry
        /// </summary>
        /// <param name="args">command line parameters</param>
        /// <returns>error code. 0=no error. 1=error detected.</returns>
        static int Main(string[] args)
        {
            // Parse command line
            Dictionary parameters = ParseCommandLine(args);

            try
            {
                // Update all forms in library
                UpdateForms(parameters);
                Console.WriteLine("Done.");
                return 0;
            }
            catch (KeyNotFoundException)
            {
                // Command line error
                Console.WriteLine("Usage: UpdateIPFormTemplateLocation.exe -web [web url] -lib [library name] -loc [form template url]");
                Console.WriteLine("Example: UpdateIPFormTemplateLocation.exe -web http://www.yourdomain.com/yourweb -lib yourforms -loc http://www.anotherdomain.com/MyForm.xsn");
                Console.WriteLine("Execution aborted.");
                return 1;
            }
            catch (Exception e)
            {
                // Execution error
                Console.WriteLine(e.Message);
                Console.WriteLine("Execution aborted.");
                return 1;
            }
        }
        /// <summary>
        /// Update all forms of a form library
        /// </summary>
        private static void UpdateForms(Dictionary parameters)
        {
            // Get site
            string absWebUrl = parameters["web"];
            string libName = parameters["lib"];
            string templateUrl = parameters["loc"];

            // Open site
            using (SPSite site = new SPSite(absWebUrl))
            {
                // Get site relative web url
                string webUrl = absWebUrl.Replace(site.Url, "");

                // Open web
                using (SPWeb web = site.OpenWeb(webUrl))
                {
                    // Walk through the library
                    SPDocumentLibrary lib = web.Lists[libName] as SPDocumentLibrary;
                    foreach (SPListItem item in lib.Items)
                    {
                        // Update the InfoPath form
                        UpdateForm(item, templateUrl);

                        // Sleep a little bit to give others a chance too
                        Thread.Sleep(_SleepTime);
                    }
                }
            }
        }
        /// <summary>
        /// Update an InfoPath form
        /// </summary>
        /// <param name="item">the InfoPath form</param>
        /// <param name="formTemplateUrl">the InfoPath form template location</param>
        private static void UpdateForm(SPListItem item, string formTemplateUrl)
        {
            // Output progress message
            Console.WriteLine("Updating \"" + item.File.Name + "\" ...");

            // Create new xml document
            XmlDocument form = new XmlDocument();

            // Load InfoPath form
            using (MemoryStream inStream = new MemoryStream(item.File.OpenBinary()))
            {
                form.Load(inStream);
            }

            // Replace form template url
            ReplaceTemplateReference(form, formTemplateUrl);

            // Save document
            using (MemoryStream outStream = new MemoryStream())
            {
                form.Save(outStream);
                outStream.Seek(0, SeekOrigin.Begin);
                item.File.SaveBinary(outStream);
            }
        }
        /// <summary>
        /// Replace the form template reference of an InfoPath form
        /// </summary>
        /// <param name="form">the InfoPath form</param>
        /// <param name="formTemplateUrl">url of the form template</param>
        private static void ReplaceTemplateReference(XmlDocument form, string formTemplateUrl)
        {
            // Select the InfoPath processing-instruction (pi)
            XmlNode pi = form.SelectSingleNode("processing-instruction('mso-infoPathSolution')");

            // Parse the pi value and replace the href attribute value
            string[] attrs = pi.Value.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            string newPiValue = string.Empty;
            foreach (string attr in attrs)
            {
                // Insert separator
                newPiValue += " ";

                // If href attribute replace value otherwise keep all
                newPiValue += (attr.StartsWith("href")) ? "href=\"" + formTemplateUrl + "\"" : attr;
            }

            // Set new pi value
            pi.Value = newPiValue.Trim();
        }
        /// <summary>
        /// Parse command line parameters
        /// </summary>
        /// <param name="args">command line parameters</param>
        /// <returns>parsed command line</returns>
        private static Dictionary ParseCommandLine(string[] args)
        {
            Dictionary<string, string> dictionary = new Dictionary<string, string>();
            for (int i = 0; i < args.Length; i++)
            {
                if (args[i].StartsWith("-") && i + 1 < args.Length)
                {
                    // Add parameter name and its value to dictionary
                    dictionary.Add(args[i].Substring(1).ToLower(), args[++i]);
                }
            }

            //Done
            return dictionary;
        }
    }
}