Initial commit

.gitignore

@@ -0,0 +1,3 @@
+.vs/
+bin/
+obj/

GPS.XML.Utils.Tests/GPS.XML.Utils.Tests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
+    <PackageReference Include="NUnit" Version="3.13.2" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
+    <PackageReference Include="coverlet.collector" Version="3.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\GPS.XML.Utils\GPS.XML.Utils.csproj" />
+  </ItemGroup>
+
+</Project>

GPS.XML.Utils.Tests/XMLHelperTests.cs

@@ -0,0 +1,66 @@
+using com.cloudsoft.utils;
+using NUnit.Framework;
+using System;
+
+namespace GPS.XML.Utils.Tests
+{
+    public class XMLHelperTests
+    {
+        [SetUp]
+        public void Setup()
+        {
+        }
+
+        [Test]
+        public void SimpleTestWithNode()
+        {
+            var expectedXml = "<test><node1>nodeval</node1></test>";
+            var xml = new XMLHelper("test");
+            xml.appendNode("node1").setValue("nodeval");
+            Console.WriteLine(xml.getXML());
+            Assert.AreEqual(expectedXml, xml.getXML());
+        }
+
+        [Test]
+        public void SimpleTestWithNodeAndAttribute()
+        {
+            var expectedXml = "<test><node1 attribute=\"1\">nodeval</node1></test>";
+            var xml = new XMLHelper("test");
+            var node1 = xml.appendNode("node1");
+            node1.appendAttribute("attribute", "1");
+            node1.setValue("nodeval");
+                
+            Console.WriteLine(xml.getXML());
+            Assert.AreEqual(expectedXml, xml.getXML());
+        }
+
+        [Test]
+        public void SimpleSelectTestFromDB()
+        {
+            var db = new DBHelper("test");
+            var xml = db.getDOM("select * from [Transaction]");
+            Console.WriteLine(xml.getXML());
+        }
+
+        [Test]
+        public void SimpleTestFromDB()
+        {
+            var db = new DBHelper("test");
+            var xml = db.getTables();
+            Console.WriteLine(xml.nodeCount("rows/row"));
+            Console.WriteLine(xml.getXML());
+            Console.WriteLine(xml.getJSON());
+        }
+        
+        [Test]
+        public void SimpleSelectTesWithParamstFromDB()
+        {
+            var oRequest = new XMLHelper("request");
+            oRequest.appendNode("status", "14");
+            var db = new DBHelper(oRequest);
+            var xml = db.getDOM("select * from Cards where Status = v:status");
+            Console.WriteLine(xml.getXML());
+            Console.WriteLine(xml.getJSON());
+        }
+    }
+}

GPS.XML.Utils.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.32014.148
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GPS.XML.Utils.Tests", "GPS.XML.Utils.Tests\GPS.XML.Utils.Tests.csproj", "{88387400-A7FB-4A7B-A59B-4A161F68F86C}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GPS.XML.Utils", "GPS.XML.Utils\GPS.XML.Utils.csproj", "{5BD260E8-9AC8-48B8-BDE4-3FBAFA78C586}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{88387400-A7FB-4A7B-A59B-4A161F68F86C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{88387400-A7FB-4A7B-A59B-4A161F68F86C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{88387400-A7FB-4A7B-A59B-4A161F68F86C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{88387400-A7FB-4A7B-A59B-4A161F68F86C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5BD260E8-9AC8-48B8-BDE4-3FBAFA78C586}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5BD260E8-9AC8-48B8-BDE4-3FBAFA78C586}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5BD260E8-9AC8-48B8-BDE4-3FBAFA78C586}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5BD260E8-9AC8-48B8-BDE4-3FBAFA78C586}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {93841CE7-2EF7-4381-9BF4-49AB13FD100F}
+	EndGlobalSection
+EndGlobal

GPS.XML.Utils/GPS.XML.Utils.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Data.SqlClient" Version="4.8.3" />
+  </ItemGroup>
+
+</Project>

GPS.XML.Utils/Program.cs

@@ -0,0 +1,2 @@
+// See https://aka.ms/new-console-template for more information
+Console.WriteLine("Hello, World!");

GPS.XML.Utils/Utils/DBHelper.cs

@@ -0,0 +1,1208 @@
+using System.Collections;
+using System.Data;
+using System.Data.Common;
+using System.Data.SqlClient;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+
+namespace com.cloudsoft.utils
+{
+
+    /// <summary>
+    ///  Class contains methods for performing database queries
+    /// </summary>
+    public class DBHelper
+    {
+
+        private Boolean _pbUppercaseNodes = false;
+        private String _pzDateFormat = "dd-MMM-yyyy HH:mm:ss";
+
+        private String pzSystem = "";
+        private String pzSchema = "";
+        private XMLHelper _request = null;
+        private Boolean lbAutoCommit = true;
+        private DbConnection oConnection = null;
+        private ArrayList _aParser = null;
+        private DBParams _Command = null;
+
+        public DBHelper(XMLHelper oRequest)
+        {
+            lbAutoCommit = (oRequest._con == null);
+            _request = oRequest;
+            pzSystem = oRequest.getString("system");
+            oConnection = oRequest._con;
+
+        }
+        
+        /// <summary>
+        /// Creates, opens, and returns a connection to the database using details specified in the registry
+        /// with the name stored in the local pzSystem variable.
+        /// </summary>
+        /// <param name="bIsRecordSet">If true then PLSQLRSet=1 is added to the connection string.</param>
+        /// <param name="bDbConnection">Whether to create an DbConnection or a standard DbConnection.</param>
+        /// <returns>An DbConnection.</returns>
+        private DbConnection getConnection()
+        {
+
+            DbConnection cn;
+
+            string zConnString = "Server=localhost,1435;Database=AlexisPTSTest;User Id=gpspl;Password=yW2S6KXdY8;"; 
+            //String zConnString = ConfigurationManager.ConnectionStrings[pzSystem].ConnectionString;
+            cn = new SqlConnection(zConnString);
+
+            try
+            {
+                cn.Open();
+            }
+            catch (Exception ex)
+            {
+                throw ex;
+            }
+
+            return cn;
+
+        }
+
+
+        //For File Loader ends here
+
+        #region Public Methods
+
+        /// <summary>Creates a new instance of DBHelper for a given system, 
+        /// defaulting to the default data provider</summary>
+        /// <param name="zSystem">The system to connect to</param>
+        /// <remarks>
+        /// A registry entry should be set up for the given system under Hkey/LocalMachine/Software/GlaxoWellcome/system
+        /// The system should have a minimum of the following:
+        /// <list type="bullet">
+        /// <item><description>DBUser</description></item>
+        /// <item><description>DBPassword</description></item>
+        /// <item><description>DBSource</description></item>
+        /// </list>
+        ///</remarks>
+        public DBHelper(String zSystem)
+        {
+            pzSystem = zSystem.ToUpper();
+        }
+        public DBHelper(String zSystem, Boolean bUppercaseNodes) : this(zSystem)
+        {
+            _pbUppercaseNodes = bUppercaseNodes;
+        }
+        public DBHelper(String zSystem, Boolean bUppercaseNodes, String zDateFormat) : this(zSystem, bUppercaseNodes)
+        {
+            _pzDateFormat = zDateFormat;
+        }
+
+        
+    /// <summary>
+    /// Creates Parameters to pass to the passed in Command type
+    /// </summary>
+    /// <param name="zCommandText">Can be either a SQL Command or a stored procedure depending on the type</param>
+    /// <param name="tCommandType">The type of Command to create parameters for</param>
+    /// <returns>The Parameters Object</returns>
+    public DBParams createSPParams(String zSQL)
+    {
+        return createSPParams(zSQL, "");
+    }
+    public DBParams createSPParams(String zSQL, XMLHelper oNode)
+    {
+        _request = oNode;
+        zSQL = parseSQL(zSQL);
+        if (_Command != null && _Command.Command != null)
+            _Command.Command.Connection.Close();
+
+        DbCommand oCommand = getConnection().CreateCommand();
+        oCommand.CommandText = zSQL;
+        _Command = new DBParams(oCommand);
+        addParserParams(oNode);
+
+        return _Command;
+    }
+    public DBParams createSPParams(String zSQL, String zXPath)
+    {
+        if (_request != null)
+            zSQL = parseSQL(zSQL);
+        if (_Command != null && _Command.Command != null)
+            _Command.Command.Connection.Close();
+
+        DbCommand oCommand = getConnection().CreateCommand();
+        oCommand.CommandText = zSQL; 
+        _Command = new DBParams(oCommand);
+        if (zXPath.Equals(""))
+            addParserParams();
+        else
+            addParserParams(zXPath);
+        return _Command;
+    }
+        
+    public String parseSQL(String zSQL)
+    {
+        _aParser = new ArrayList();
+        return parseSQL(zSQL, false);
+    }
+
+        public String parseSQL(String zSQL, Boolean bConditional)
+    {
+        try
+        {
+        //Make sure square brackets are even
+        int iEven = 0;
+        for(int i = 0, n = zSQL.Length ; i < n ; i++)
+        {
+            char c = zSQL[i];
+            if (c == '[') iEven++;
+            if (c == ']') iEven--;
+        }
+        if (iEven != 0)
+        {
+            throw new Exception("Square brackets must be matched");
+        }
+
+        // Find optional clauses
+        Regex regex = new Regex("\\[([^\\[\\]]+|\\[([^\\[\\]]+|\\[([^\\[\\]]+)*\\])*\\])*\\]");
+        Match matcher = regex.Match(zSQL);
+        int iCurr = 0;
+        StringBuilder sb = new StringBuilder();
+        while (matcher.Success)
+        {
+            sb.Append(replaceSQLVars(zSQL.Substring(iCurr, matcher.Index - iCurr), bConditional));
+            //iCurr = matcher.start() + matcher.end();
+            iCurr = matcher.Index + matcher.Length;
+            String match = matcher.Groups[0].Value;
+            match = match.Substring(1, match.Length - 2);
+            if (matcher.Groups[2].Value != null)
+                sb.Append(parseSQL(match,true));
+            else
+                sb.Append(replaceSQLVars(match, true));
+            matcher = matcher.NextMatch();
+        }
+
+            sb.Append(replaceSQLVars(zSQL.Substring(iCurr), bConditional));
+            return sb.ToString();
+        }
+        catch (Exception ex)
+        {
+            return "";
+        }
+    }
+
+    private String replaceSQLVars(String zSQL, Boolean bConditional)
+    {
+        try
+        {
+            // Find variables to replace
+            Regex regex = new Regex("[vilcbotdf]?:[@a-z_0-9./]*");
+            Match matcher = regex.Match(zSQL);
+            StringBuilder sb = new StringBuilder();
+            int iCurr = 0;
+            while (matcher.Success)
+            {
+                // Get the replace value
+                String match = matcher.Groups[0].Value;
+                String zMatch = match.Substring(match.IndexOf(':')+1);
+                char zMatchType = match[0];
+
+                // If this is a conditional replace return nothing as soon as a variable is empty
+                //if (bConditional && _request.getString(zMatch) == "" && zMatchType != 'o')
+                if (bConditional && _request.getString(zMatch).Equals(""))
+                    return "";
+                String zTextBefore = zSQL.Substring(iCurr, matcher.Index - iCurr);
+                String zReplace = "";
+                switch (zMatchType)
+                {
+                    case ':':
+                    case 'o': zReplace = _request.getString(zMatch);
+                        //if (zReplace == "") zReplace = "=";
+                        if (zReplace.Equals("soundex"))
+                        {
+                            String[] arrWords = zTextBefore.Split(' ');
+                            zReplace += "(" + arrWords[arrWords.Length-1] + ") = ";
+                            zTextBefore = "";
+                            for (int i = 0; i < arrWords.Length - 1; i++)
+                                zTextBefore += arrWords[i] + " ";
+                        }
+                        break;
+                    case 'i':
+                    case 'f':
+                    case 't':
+                    case 'd':
+                    case 'b':
+                        zReplace = $"@{zMatch}";
+                        _aParser.Add(match);
+                        break;
+                    default:
+                        zReplace = $"@{zMatch}"; ;
+                        String zOp = _request.getString("op_" + zMatch);
+                        if (zOp.Equals("soundex"))
+                            zReplace = "soundex('" + zReplace + "')";
+                        else if (zOp.Equals("like"))
+                            match = "l:" + zMatch;
+                        _aParser.Add(match);
+                        break;
+                }
+                sb.Append(zTextBefore);
+                iCurr = matcher.Index +  matcher.Length;
+                sb.Append(zReplace);
+                matcher = matcher.NextMatch();
+            }
+            sb.Append(zSQL.Substring(iCurr));
+            return sb.ToString();
+        }
+        catch (Exception ex)
+        {
+            return "";
+        }
+    }
+    private void addParserParams()
+    {
+        addParserParams(_request);
+    }
+    private void addParserParams(String zXPath)
+    {
+        foreach (XMLHelper oNode in _request.getNodes(zXPath))
+        {
+            addParserParams(oNode);
+            //_Command.addBatch();
+        }
+    }
+    private void addParserParams(XMLHelper oNode)
+    {
+        if (_aParser is null)
+            return;
+
+        for (int i=0; i < _aParser.Count; i++)
+        {
+            // Get the replace value
+            String match = _aParser[i] as string;
+            String zMatch = match.Substring(match.IndexOf(':')+1);
+            char zMatchType = match[0];
+            Object oParam = null;
+            String zValue = (zMatch.Equals("xml_data")) ? oNode.getNode(zMatch).getFirstChild().getXML() : oNode.getString(zMatch);
+            DbType iType = DbType.String;
+            switch (zMatchType)
+            {
+                case 'f': oParam = oNode.getDouble(zMatch);
+                    iType = DbType.Decimal;
+                    break;
+                case 'i': oParam = oNode.getInt(zMatch);
+                    iType = DbType.Int32;
+                    break;
+                case 't': oParam = oNode.getSQLDateTime(zMatch);
+                    iType = DbType.DateTime;
+                    break;
+                case 'd': oParam = oNode.getSQLDate(zMatch);
+                    iType = DbType.Date;
+                    break;
+                case 'b': oParam = (oNode.getBoolean(zMatch)) ? "Y" : "N";
+                    zValue = (String) oParam;
+                    iType = DbType.Boolean;
+                    break;
+                case 'c': oParam = zValue;
+                    iType = DbType.String;
+                    break;
+                case 'l': oParam = "%" + zValue + "%";
+                    zValue = (String) oParam;
+                    break;
+                default: oParam = zValue;
+                    break;
+            }
+            if (zValue.Length == 0)
+                oParam = null;
+
+            _Command.set($"@{zMatch}", oParam, iType);
+        }
+
+    }
+        
+        /// <summary>
+        /// Legacy method - now superseded by createDBSPParams
+        /// </summary>
+        public DBParams createSPParams(String zCommandText, CommandType tCommandType)
+        {
+            DbCommand oCommand = getConnection().CreateCommand();
+            oCommand.CommandType = tCommandType;
+            oCommand.CommandText = zCommandText;
+            return new DBParams(oCommand);
+        }
+
+
+        /// <summary>
+        /// Executes a store procedure optionally returning output parameters
+        /// This is not used for returning recordsets as XML, but for transactional stored procedures
+        /// </summary>
+        /// <param name="oParams">DBParams Parameters</param>
+        /// <returns>An XMLHelper with any output parameters</returns>
+        public XMLHelper execute(DBParams oParams)
+        {
+            //return execute(oParams, false);
+            return execute(oParams, false);
+        }
+
+        /// <summary>
+        /// Executes a SQL Query
+        /// This is not used for returning recordsets as XML, but for transactional stored procedures
+        /// </summary>
+        /// <param name="zSQL">DBParams Parameters</param>
+        /// <returns>An XMLHelper with any output parameters</returns>
+        public XMLHelper execute(String zSQL)
+        {
+            DBParams oParams = createSPParams(zSQL, CommandType.Text);
+            return execute(oParams, false);
+        }
+
+
+        /// <summary>
+        /// Executes a store procedure optionally returning output parameters
+        /// This is not used for returning recordsets as XML, but for transactional stored procedures
+        /// </summary>
+        /// <param name="oParams">DBParams Parameters</param>
+        /// <returns>An XMLHelper with any output parameters</returns>
+        public XMLHelper execute(DBParams oParams, Boolean bKeepOpen)
+        {
+            return executeODAC(oParams, bKeepOpen);
+        }
+
+        #endregion 
+
+        #region ODAC Specific Private Methods
+
+        /// <summary>
+        /// Executes a store procedure optionally returning output parameters
+        /// This is not used for returning recordsets as XML, but for transactional stored procedures
+        /// </summary>
+        /// <param name="oParams">DBParams Parameters</param>
+        /// <param name="bKeepOpen">Flag to determine if the connection is kept open or not</param>
+        /// <returns>An XMLHelper with any output parameters</returns>
+        private XMLHelper executeODAC(DBParams oParams, Boolean bKeepOpen)
+        {
+            DateTime dStart = DateTime.Now;
+            XMLHelper oResponse = new XMLHelper("response");
+            oResponse.appendNode("rows", Convert.ToString(oParams.ExecuteNonQuery()));
+            foreach (DbParameter oParam in oParams.ODACParameters())
+            {
+                if (oParam.Direction == System.Data.ParameterDirection.Output)
+                {
+                    oResponse.appendNode(oParam.ParameterName.Replace(":", ""), oParam.Value.ToString());
+                }   
+            }
+            TimeSpan tDiff = DateTime.Now.Subtract(dStart);
+            oResponse.appendAttribute("duration", tDiff.TotalMilliseconds.ToString());
+            if (!bKeepOpen)
+            {
+                oParams.CloseConnection();
+                oParams.CloseCommand();
+            }
+            return oResponse;
+        }
+
+
+
+        /// <summary>
+        /// Creates Parameters to pass to a Stored Procedure. Also calls getConnection to get an
+        /// DbConnection, and appends the required RefCursor.
+        /// </summary>
+        /// <param name="zCommandText">The stored procedure to be called</param>
+        /// <returns>The Parameters Object</returns>
+        /// <example>
+        /// DBHelper oDB = new DBHelper("uki");
+        /// DBParams oCommand = oDB.createOracleSPParams("pkg_orgcusts.RetrieveTargetOrgsByBrand");
+        /// </example>
+        private DBParams createODACSPParams(String zCommandText, CommandType tCommandType, Boolean bindByName)
+        {
+            DbCommand oCommand = getConnection().CreateCommand();
+            oCommand.CommandType = tCommandType;
+            
+            switch (tCommandType)
+            {
+                case CommandType.Text:
+                    {
+                        oCommand.CommandText = zCommandText;
+                        break;
+                    }
+                case CommandType.StoredProcedure:
+                case CommandType.TableDirect:
+                    {
+                        oCommand.CommandText = pzSchema + "." + zCommandText;
+                        break;
+                    }
+            }
+
+            return new DBParams(oCommand);
+        }
+
+
+        #endregion
+
+        public void closeConnection(DBParams oCommand)
+        {
+            oCommand.CloseConnection();
+        }
+
+        #region Overrides for Get Dom
+
+        public XMLHelper getDOM(IDataReader oRS)
+        {
+            return getDOM(oRS, 0, 2000);
+        }
+        /// <summary>
+        /// Gets a DOM of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <returns>An XMLHelper representation of the recordset in the format response/rows/row</returns>
+        public XMLHelper getDOM(IDataReader oRS, int iStartRow, int iMaxRows)
+        {
+            return appendToDOM(null, null, null, null, oRS, "rows", "row", iStartRow, iMaxRows, true, RefCurPosition.First, false, true, false);
+        }
+        /// <summary>
+        /// Gets a DOM of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <returns>An XMLHelper representation of the recordset in the format response/rows/row</returns>
+        public XMLHelper getDOM(String zSQL)
+        {
+            _Command = createSPParams(zSQL);
+            return getDOM(_Command, "rows", "row");
+        }
+        /// <summary>
+        /// Gets a DOM of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <returns>An XMLHelper representation of the recordset in the format response/rows/row</returns>
+        public XMLHelper getDOM(DBParams oCommand, String zRowsetName, String zRowName)
+        {
+            return getDOM(oCommand, 0, 0, false, RefCurPosition.First, zRowsetName, zRowName, false, true, null, null, null, null, false);
+        }
+        /// <summary>
+        /// Gets a DOM of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <returns>An XMLHelper representation of the recordset in the format response/rows/row</returns>
+        public XMLHelper getDOM(DBParams oCommand, Boolean withRefCur)
+        {
+            
+            RefCurPosition refCurPosition = RefCurPosition.None;
+            if (withRefCur)
+                refCurPosition = RefCurPosition.First;
+
+            return getDOM(oCommand, 0, 0, false, refCurPosition, "rows", "row", false, true, null, null, null, null, false);
+
+        }
+
+        /// <summary>
+        /// Gets a XML DOM of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <param name="iStartRow">The start row number to retrieve</param>
+        /// <param name="iMaxRows">The maximum number of rows</param>
+        /// <param name="bShowTotal">Determines whether the total Rowcount is shown.</param>
+        /// <param name="zRowsetName">The Rowset node name.</param>
+        /// <param name="zRowName">The Row node name</param>
+        /// <param name="bShowMetadata">Determines whether to create meta data info</param>
+        /// <returns>An XMLHelper representation of the recordset</returns>
+        public XMLHelper getDOM(DBParams oCommand, int iStartRow, int iMaxRows, Boolean bShowTotal, DBHelper.RefCurPosition refCurPosition,
+            String zRowsetName, String zRowName, Boolean bShowMetadata, Boolean bCloseConnection, 
+            XMLHelper oInputDOM, String zNode, String zKey, String zGrouping, Boolean CheckRowName)
+        {
+
+            //Time the processing...
+            DateTime dStart = DateTime.Now;
+
+            //Execute the database Command...
+            XMLHelper oResponse = appendToDOM(oInputDOM, zNode, zKey, zGrouping, oCommand, zRowsetName, zRowName, iStartRow, iMaxRows, bShowTotal, refCurPosition, bShowMetadata, false, CheckRowName);
+            
+            //Add the execution time to the ouptut...
+            TimeSpan tDiff = DateTime.Now.Subtract(dStart);
+            oResponse.appendAttribute("duration", tDiff.TotalMilliseconds.ToString());
+            
+            //Close the connection if required...
+            if (bCloseConnection)
+            {
+                oCommand.CloseConnection();
+            }
+
+            return oResponse;
+
+        }
+
+        #endregion
+
+        #region Overrides for Append To DOM
+
+        /// <summary>
+        /// Executes a Command and adds the recordset to an existing DOM
+        /// </summary>
+        /// <param name="oInputDom">Dom to append to</param>
+        /// <param name="zNode">Xpath to the node to append information to</param>
+        /// <param name="zKey">Key to match</param>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <param name="zRowsetName">The Rowset node name</param>
+        /// <param name="zRowName">The row Node Name</param>
+        public void appendToDOM(XMLHelper oInputDom, String zNode, String zKey, DBParams oCommand, String zRowsetName, String zRowName)
+        {
+            appendToDOM(oInputDom, zNode, zKey, null, oCommand, zRowsetName, zRowName, 0, 9999999,
+                false, (oCommand.Command.CommandType == CommandType.Text ? RefCurPosition.None : RefCurPosition.First), false, false, false); 
+            //appendToDOM(oInputDom, zNode, zKey, oCommand, zRowsetName, zRowName, 0, 9999999, false, false);
+        }
+
+        /// <summary>
+        ///  Executes a Command and adds the recordset to an existing DOM
+        /// </summary>
+        /// <param name="oInputDom">Dom to append to</param>
+        /// <param name="zNode">Xpath to the node to append information to</param>
+        /// <param name="zKey">Key to match</param>
+        /// <param name="oParams">Parameters to pass to the stored procedure</param>
+        /// <param name="zRowsetName">The Rowset node name</param>
+        /// <param name="zRowName">The row Node Name</param>
+        /// <param name="iStartRow">The start row number</param>
+        /// <param name="iMaxRows">The maximun number of rows to fetch</param>
+        /// <param name="bShowTotal">Determines whether totals are shown</param>
+        /// <param name="bShowMetadata">Determines whether metadata is to be shown</param>
+        /// 
+        public void appendToDOM(XMLHelper oInputDom, String zNode, String zKey, DBParams oParams, String zRowsetName, String zRowName, int iStartRow, int iMaxRows, Boolean bShowTotal, Boolean bShowMetadata)
+        {
+            appendToDOM(oInputDom, zNode, zKey, null, oParams, zRowsetName, zRowName, iStartRow, iMaxRows, 
+                        bShowTotal, RefCurPosition.None, false, false, false);
+        }
+        
+        /// <summary>
+        /// Executes a Command and adds the recordset to an existing DOM
+        /// JF 12/2007 - Generalised to take an IDbCommand, allowing it to be used with either an
+        ///              DbCommand or DbCommand
+        /// </summary>
+        /// <param name="oInputDom">Dom to append to</param>
+        /// <param name="zNode">Xpath to the node to append information to</param>
+        /// <param name="zKey">Key to match</param>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <param name="zRowsetName">The Rowset node name</param>
+        /// <param name="zRowName">The row Node Name</param>
+        /// <param name="iStartRow">The start row number</param>
+        /// <param name="iMaxRows">The maximun number of rows to fetch</param>
+        /// <param name="bShowTotal">Determines whether totals are shown</param>
+        /// <param name="bShowMetadata">Determines whether metadata is to be shown</param>
+        /// <param name="bCloseConnection">Whether to close the Commands connection when finished exection</param>
+        /// <param name="CheckRowName">This is an override to force a check of the row name against any xpath which 
+        /// may have been defined in the column name from the procedure/package. It's function is to avoid the creation
+        /// of a dom structure such as rows/row/row if the xpath in the procedure reads row/@value. If the first component
+        /// of the xpath in the procedure matches the rowname specified in the call to this method, then it will assume
+        /// that you don't want to append a new child with the same name. It will still allow the creation of 
+        /// rows/row/childrow if the procedure reads childrow/@value.</param>
+        public XMLHelper appendToDOM(XMLHelper oInputDom, String zNode, String zKey, String zGrouping, DBParams oParams, 
+            String zRowsetName, String zRowName, int iStartRow, int iMaxRows, 
+            Boolean bShowTotal, DBHelper.RefCurPosition refCurPosition, Boolean bShowMetadata, Boolean bCloseConnection,
+            Boolean CheckRowName)
+        {
+
+
+            #region Execute the database Command
+
+            //Execute the Command and obtain the output recordset...
+            DbCommand oCommand = oParams.AsDbCommand();
+
+            //oCommand.Prepare();
+
+            CommandBehavior cb = CommandBehavior.Default;
+            if (bCloseConnection)
+            {
+                cb = CommandBehavior.CloseConnection;
+            }
+            IDataReader oRS = oCommand.ExecuteReader(cb);
+            
+            #endregion
+
+            //Return the response (the input dom may also have been appended to inline)...
+            return appendToDOM(oInputDom, zNode, zKey, zGrouping, oRS, zRowsetName, zRowName, iStartRow, iMaxRows, bShowTotal, refCurPosition, bShowMetadata, bCloseConnection, CheckRowName);
+            
+        }
+
+        public XMLHelper appendToDOM(XMLHelper oInputDom, String zNode, String zKey, String zGrouping, IDataReader oRS,
+            String zRowsetName, String zRowName, int iStartRow, int iMaxRows,
+            Boolean bShowTotal, DBHelper.RefCurPosition refCurPosition, Boolean bShowMetadata, Boolean bCloseConnection,
+            Boolean CheckRowName)
+        {
+
+            //Establish output vars...
+            XMLHelper oResponse = new XMLHelper("response");
+            //XMLHelper oResponse = (oInputDom == null || oInputDom.getName() == "request") ? new XMLHelper("response") : oInputDom;
+
+            XMLHelper oInRowGroup = null;
+            XMLHelper oOutRowGroup = null;
+
+            XMLHelper oRow = null;
+
+            String zNodeValue;
+
+            Int32 lFields = oRS.FieldCount;
+
+            String[] vValue = null;
+            Int32 lGroupCols = 0;
+            String zGroupNode = null;
+            if (zGrouping != "" && zGrouping != null)
+            {
+                vValue = zGrouping.Split(":".ToCharArray());
+                lGroupCols = Convert.ToInt32(vValue[0]);
+                zGroupNode = vValue[1];
+            }
+
+            //Determine whether to create a grouping node...
+            if (zRowsetName != "" && zRowsetName != null)
+            {
+                //Append a grouping node to the response to hold child nodes...
+                oOutRowGroup = oResponse.appendNode(zRowsetName);
+            }
+            else
+            {
+                //Appending child nodes directly to the response root, rather than a grouping node...
+                oOutRowGroup = oResponse;
+            }
+
+            // Create a collection of keys in the DOM
+            Dictionary<String, XMLHelper> oColKeys = new Dictionary<String, XMLHelper>();
+            if (zNode != "" && zNode != null)
+            {
+
+                XMLHelper[] oNodes = oInputDom.getNodes(zNode);
+                for (int i = 0; i < oNodes.Length; i++)
+                {
+
+                    XMLHelper oNode = oNodes[i];
+                    if (zRowsetName != "" && zRowsetName != null)
+                    {
+                        oInRowGroup = oNode.appendNode(zRowsetName);
+                    }
+                    else
+                    {
+                        oInRowGroup = oNode;
+                    }
+
+                    if (zKey != "" && zKey != null)
+                        oColKeys.Add(oNodes[i].getValue(zKey), oInRowGroup);
+
+                }
+
+            }
+
+            //If you are required to append "Metadata", then 
+            //append column names and types...
+            if (bShowMetadata)
+            {
+                XMLHelper oMeta = oResponse.appendNode("meta_data");
+                XMLHelper oCols = oMeta.appendNode("columns");
+                for (int i = 0; i < oRS.FieldCount; i++)
+                {
+                    XMLHelper oNode = oCols.appendNode("column");
+                    oNode.appendAttribute("name", oRS.GetName(i).ToLower());
+                    oNode.appendAttribute("type", oRS.GetDataTypeName(i));
+                }
+            }
+
+            #region Deal with paging
+
+            // Set the start row and max rows. Unless maxrows has been explicitly 
+            //defined then default to a safe value (2000 in this case)...
+            int iRow = iStartRow;
+            if (iMaxRows == 0)
+                iMaxRows = Int32.MaxValue;
+            //iMaxRows = 2000;
+
+            //If you are "paging", then a startrow will be provided, so 
+            //advance to the startrow of this page...
+            if (iStartRow > 0)
+            {
+                for (int i = 0; i < iStartRow; i++)
+                    oRS.Read();
+            }
+
+            #endregion
+
+            String zCurrRowKey = null;
+            String zPrevRowKey = null;
+            Boolean bFirst = true;
+            XMLHelper oTempNode = null;
+            Int32 lField = 0;
+
+            //  Loop through the recordset and construct the XML DOM
+            while (oRS.Read() && iRow < (iMaxRows + iStartRow))
+            {
+
+                if (iRow >= iStartRow)
+                {
+
+                    bFirst = true;
+
+                    // Get the "Key" for this row. Used to determine whether this should be a new grouping.
+                    zCurrRowKey = null;
+                    for (lField = 0; lField <= lGroupCols - 1; lField++)
+                    {
+                        zCurrRowKey += (string)oRS[lField].ToString() + "-";
+                    }
+
+                    if (!string.IsNullOrEmpty(zKey))
+                    {
+                        oInRowGroup = oColKeys[oRS[0].ToString()];
+                    }
+
+                    //If you aren't grouping, or if this key is new...
+                    if (lGroupCols == 0 || zCurrRowKey != zPrevRowKey)
+                    {
+                        //Create a new node...
+                        oRow = new XMLHelper(zRowName);
+                        if (oInRowGroup != null)
+                        {
+                            oRow = oInRowGroup.appendNode(oRow);
+                        }
+                        oTempNode = oRow;
+                    }
+
+                    lField = 0;
+                    for (int i = 0; i < oRS.FieldCount; i++)
+                    {
+                        //DataRow oField = oRS.[i];
+                        if (lField >= lGroupCols || zCurrRowKey != zPrevRowKey)
+                        {
+                            //vValue = oField.Value;
+                            zNodeValue = "";
+
+                            //  Get the data from the field
+                            if (oRS.GetFieldType(i).Name =="DateTime")
+                            {
+                                if (oRS.IsDBNull(i))
+                                    zNodeValue = "";
+                                else
+                                    zNodeValue = oRS.GetDateTime(i).ToString(_pzDateFormat);
+                            }
+                            else
+                            {
+                                if (oRS.IsDBNull(i))
+                                    zNodeValue = "";
+                                else
+                                    zNodeValue = oRS[i].ToString();
+                            }
+
+                            String zNodeName = oRS.GetName(i).ToLower().Replace("\"", "");
+                            if (_pbUppercaseNodes)
+                                zNodeName = zNodeName.ToUpper();
+                            //This is an override to check the row name during an append.
+                            //See procedure definition comment for an explanation...
+                            if (CheckRowName && zNodeName.Split("/".ToCharArray()).Length > 1)
+                            {
+                                if (zRowName == zNodeName.Split("/".ToCharArray())[0])
+                                    zNodeName = zNodeName.Replace(zRowName + "/", "");
+                            }
+
+                            //  Add the field to the current row
+                            if (bFirst & !string.IsNullOrEmpty(zKey))
+                            {
+                                //Do Nothing...
+                            }
+                            else if (lGroupCols == lField & lGroupCols > 0)
+                            {
+                                oRow = oRow.appendNode(zGroupNode);
+                                oRow.appendXPathNode(zNodeName, zNodeValue, false);
+                            }
+                            else
+                            {
+                                //if this is a value node rather than an attribute, 
+                                //and if it is a match to the node name...
+                                if (CheckRowName &&
+                                    (zNodeName == zRowName) &&
+                                    !zNodeName.Contains("@")
+                                    )
+                                {
+                                    //Just set the node value...
+                                    oRow.setValue(zNodeValue);
+                                }
+                                else
+                                {
+                                    if (zNodeName == "xml-data" || zNodeName.EndsWith("_xml"))
+                                        oRow.appendNode(new XMLHelper("<" + zNodeName + ">" + zNodeValue + "</" + zNodeName + ">"));
+                                    else
+                                        oRow.appendXPathNode(zNodeName, zNodeValue, false);
+                                }
+                            }
+
+                        }
+                        bFirst = false;
+                        lField = lField + 1;
+                    }
+
+                    oRow = oTempNode;
+
+                    //If you are dom merging, append to the inrowgroup...
+                    //if (oInRowGroup != null)
+                    //    oInRowGroup.appendNode(oRow);
+
+                    //Always append to the outrowgroup...
+                    oOutRowGroup.appendNode(oRow);
+
+                    zPrevRowKey = zCurrRowKey;
+
+                }
+
+                iRow++;
+
+            }
+
+            //  If total is to be shown move to the end of the recordset
+            if (bShowTotal)
+            {
+
+                //Need to read the remaining rows in the recordset to count rows...
+                bool additionalRowsCounted = false;
+                while (oRS.Read() && iRow < 2000)
+                {
+                    additionalRowsCounted = true;
+                    iRow++;
+                }
+
+                //if ((iStartRow == 0) && (additionalRowsCounted))
+                //    iRow++;
+
+                //if (iStartRow > 0)
+                //    iRow--;
+                if (additionalRowsCounted)
+                    iRow++;
+
+                //Append the rowcount to the returned results...
+                oResponse.appendAttribute("total_rows", Convert.ToString(iRow));
+                //oResponse.appendNode("total_rows", Convert.ToString(iRow));
+
+            }
+
+            //Always close the recordset...
+            oRS.Close();
+
+            //Return the response (the input dom may also have been appended to inline)...
+            return oResponse;
+
+        }
+        
+        public XMLHelper getTables()
+        {
+            XMLHelper oResponse = null;
+            try
+            {
+                DataTable dt = getConnection().GetSchema("Tables");
+                oResponse = getDOM(dt);
+            }
+            catch (Exception ex)
+            {
+            }
+            return oResponse;
+        }
+        public XMLHelper getColumns(String zTable)
+        {
+            XMLHelper oResponse = null;
+            try
+            {
+
+                DbCommand cmd = getConnection().CreateCommand();
+                cmd.CommandText = "select * from " + zTable;
+                IDataReader rs = cmd.ExecuteReader();
+                oResponse = getDOM(rs.GetSchemaTable());
+            }
+            catch (Exception ex)
+            {
+            }
+            return oResponse;
+        }
+        public XMLHelper getDOM(DataTable dt)
+        {
+            XMLHelper oResponse = new XMLHelper("response");
+            XMLHelper oRows = oResponse.appendNode("rows");
+            foreach (DataRow dr in dt.Rows)
+            {
+                XMLHelper oRow = oRows.appendNode("row");
+                foreach (DataColumn dc in dt.Columns)
+                {
+                    oRow.appendNode(dc.ColumnName.ToLower(), dr[dc].ToString());
+                }
+            }
+            return oResponse;
+        }
+        #endregion
+
+        #region Overrides for Get XML
+        
+        public enum RefCurPosition
+        {
+            First,
+            Last,
+            None
+        }
+
+        /// <summary>
+        /// Gets an XML String of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <returns>An XML string representation of the recordset in the format response/rows/row</returns>
+        public String getXML(DBParams oCommand)
+        {
+            return getDOM(oCommand, true).getXML();
+        }
+
+        public String getXML(DBParams oCommand, Boolean withRefCur)
+        {
+            return getDOM(oCommand, withRefCur).getXML();
+        }
+
+        /// <summary>
+        /// Gets an XML String of a recordset
+        /// </summary>
+        /// <param name="oCommand">Parameters to pass to the stored procedure</param>
+        /// <param name="iStartRow">The start row number to retrieve</param>
+        /// <param name="iMaxRows">The maximum number of rows</param>
+        /// <param name="bShowTotal">Determines whether the total Rowcount is shown.</param>
+        /// <param name="zRowsetName">The Rowset node name.</param>
+        /// <param name="zRowName">The Row node name</param>
+        /// <param name="bShowMetadata">Determines whether to create meta data info</param>
+        /// <returns>An XML string representation of the recordset</returns>
+        public String getXML(DBParams oCommand, int iStartRow, int iMaxRows, Boolean bShowTotal, String zRowsetName, String zRowName, Boolean bShowMetadata)
+        {
+            return getXML(oCommand, iStartRow, iMaxRows, bShowTotal, zRowsetName, zRowName, bShowMetadata, true);
+        }
+        public XMLHelper getXMLHelper(DBParams oCommand, int iStartRow, int iMaxRows, Boolean bShowTotal, String zRowsetName, String zRowName, Boolean bShowMetadata)
+        {
+            return getXMLHelper(oCommand, iStartRow, iMaxRows, bShowTotal, zRowsetName, zRowName, bShowMetadata, true);
+        }
+
+        public String getXML(DBParams oCommand, int iStartRow, int iMaxRows, Boolean bShowTotal, String zRowsetName, String zRowName, Boolean bShowMetadata, Boolean bCloseConnection)
+        {
+            return getXML(oCommand, iStartRow, iMaxRows, bShowTotal, RefCurPosition.First, zRowsetName, zRowName, bShowMetadata, bCloseConnection, null, null, null, null, false).getXML();
+        }
+        public XMLHelper getXMLHelper(DBParams oCommand, int iStartRow, int iMaxRows, Boolean bShowTotal, String zRowsetName, String zRowName, Boolean bShowMetadata, Boolean bCloseConnection)
+        {
+            return getXML(oCommand, iStartRow, iMaxRows, bShowTotal, RefCurPosition.First, zRowsetName, zRowName, bShowMetadata, bCloseConnection, null, null, null, null, false);
+        }
+
+        public XMLHelper getXML(DBParams oCommand, int iStartRow, int iMaxRows, Boolean bShowTotal, DBHelper.RefCurPosition refCurPosition, String zRowsetName, String zRowName, Boolean bShowMetadata, Boolean bCloseConnection, XMLHelper oInputDOM, String zNode, String zKey, String zGrouping, Boolean CheckRowName)
+        {
+            return getDOM(oCommand, iStartRow, iMaxRows, bShowTotal, refCurPosition, zRowsetName, zRowName, bShowMetadata, bCloseConnection, oInputDOM, zNode, zKey, zGrouping, CheckRowName);
+        }
+
+        /// <summary>
+        /// High performance version of append to dom.
+        /// Will always add columns as attributes.
+        /// </summary>
+        public String getXML(DBParams oParams, String zRowsetName, String zRowName, Boolean bCloseConnection)
+        {
+            return getXML(oParams, zRowsetName, zRowName, bCloseConnection, null, null, null);
+        }
+
+        public String getXML(DBParams oParams, String zRowsetName, String zRowName, Boolean bCloseConnection, Int32? StartRow, Int32? MaxRows, Boolean? ShowTotal)
+        {
+            return getXMLStringBuilder(oParams, zRowsetName, zRowName, bCloseConnection, StartRow, MaxRows, ShowTotal).ToString();
+        }
+
+        public XMLHelper getXMLHelper(DBParams oParams, String zRowsetName, String zRowName, Boolean bCloseConnection, Int32? StartRow, Int32? MaxRows, Boolean? ShowTotal)
+        {
+            return new XMLHelper(getXMLStringBuilder(oParams, zRowsetName, zRowName, bCloseConnection, StartRow, MaxRows, ShowTotal));
+        }
+
+        /// <summary>
+        /// High performance version of append to dom.
+        /// Will always add columns as attributes.
+        /// </summary>
+        private StringBuilder getXMLStringBuilder(DBParams oParams, String zRowsetName, String zRowName, Boolean bCloseConnection, Int32? StartRow, Int32? MaxRows, Boolean? ShowTotal)
+        {
+
+            //Execute the procedure...
+            //System.Data.IDbCommand oCommand = oParams.AsIDbCommand();
+            DbCommand oCommand = oParams.Command;
+            IDataReader oRS = null;
+            if (bCloseConnection)
+            {
+                oRS = oCommand.ExecuteReader(CommandBehavior.CloseConnection);
+            }
+            else
+            {
+                oRS = oCommand.ExecuteReader();
+            }
+            
+            //Get the number of columns...
+            Int32 FieldCount = oRS.FieldCount;
+
+            //Get the column names (in advance of the loop, so it doesn't 
+            //need to read the rowset every time through...
+            Dictionary<Int32, String> oColumnNames = new Dictionary<Int32, String>();
+            String ColName = null;
+            for (int i = 0; i < FieldCount; i++)
+            {
+                ColName = oRS.GetName(i).ToLower();
+                if (ColName.StartsWith("@"))
+                {
+                    ColName = ColName.Substring(1);
+                }
+                oColumnNames.Add(i, ColName);
+            }
+
+            StringWriter sw = new StringWriter();
+            XmlTextWriter xtw = new XmlTextWriter(sw);
+
+            //Append a placeholder for the rows...
+            xtw.WriteStartElement("response");
+
+            if (zRowsetName != null)
+                xtw.WriteStartElement(zRowsetName);
+
+            //Paging setup...
+            if (StartRow == null) StartRow = 0;
+            if (MaxRows == null) MaxRows = 0;
+            if (MaxRows == 0) MaxRows = int.MaxValue;
+            
+            //Loop through every row in the rs, adding rows and cols appropriately...
+            Int32 rowCount = 0;
+            Boolean WriteRow = true;
+            while (oRS.Read())
+            {
+
+                //If you are at the start row...
+                if (rowCount >= StartRow && WriteRow)
+                {
+
+                    //Add a new row...
+                    xtw.WriteStartElement(zRowName);
+                    
+                    for (int i = 0; i < FieldCount; i++)
+                    {
+                        //  Add the field to the current row
+                        xtw.WriteAttributeString(oColumnNames[i].ToString(), oRS[i].ToString());
+                    }
+
+                    xtw.WriteEndElement();
+
+                    //If you have reached the max number of rows you want to paint, then stop painting...
+                    if ((rowCount - StartRow) >= (MaxRows-1))
+                        WriteRow = false;
+
+                }
+
+                rowCount++;
+
+            }
+
+            if (zRowsetName != null)
+            {
+                xtw.WriteElementString("total_rows", rowCount.ToString());
+                xtw.WriteEndElement();
+            }
+
+            xtw.WriteElementString("total_rows", rowCount.ToString());
+            xtw.WriteEndElement();
+
+            //Close the rs...
+            oRS.Close();
+            
+            //Return the built dom...
+            return sw.GetStringBuilder();
+
+        }
+
+        public StringBuilder getCSV(DBParams oParams, String zRowsetName, String zRowName, 
+            Boolean bCloseConnection, Int32? StartRow, Int32? MaxRows, Boolean? ShowTotal,
+            out long rowCount)
+        {
+
+            //Execute the procedure...
+            //System.Data.IDbCommand oCommand = oParams.AsIDbCommand();
+            DbCommand oCommand = oParams.Command;
+            DbDataReader oRS = null;
+            if (bCloseConnection)
+            {
+                oRS = oCommand.ExecuteReader(CommandBehavior.CloseConnection);
+            }
+            else
+            {
+                oRS = oCommand.ExecuteReader();
+            }
+
+            //Get the number of columns...
+            Int32 FieldCount = oRS.FieldCount;
+
+            StringWriter sw = new StringWriter();
+
+            //Get the column names (in advance of the loop, so it doesn't 
+            //need to read the rowset every time through...
+            Dictionary<Int32, String> oColumnNames = new Dictionary<Int32, String>();
+            String ColName = null;
+            for (int i = 0; i < FieldCount; i++)
+            {
+                ColName = oRS.GetName(i).ToLower();
+                if (ColName.StartsWith("@"))
+                {
+                    ColName = ColName.Substring(1);
+                }
+                oColumnNames.Add(i, ColName);
+
+                sw.Write(ColName);
+                if (i < (FieldCount - 1))
+                    sw.Write(",");
+
+            }
+
+            sw.Write(Environment.NewLine);
+
+
+            //Paging setup...
+            if (StartRow == null) StartRow = 0;
+            if (MaxRows == null) MaxRows = 0;
+            if (MaxRows == 0) MaxRows = int.MaxValue;
+
+            Type type;
+
+            //Loop through every row in the rs, adding rows and cols appropriately...
+            rowCount = 0;
+            Boolean WriteRow = true;
+            while (oRS.Read())
+            {
+
+                //If you are at the start row...
+                if (rowCount >= StartRow && WriteRow)
+                {
+
+                    for (int i = 0; i < FieldCount; i++)
+                    {
+                        
+                        type = oRS[i].GetType();
+                        if ((type == typeof(String)))
+                            sw.Write("\"");
+                        else if (oColumnNames[i] == "ean_code")  //always output ean codes as text to avoid conversion by excel to exponents
+                            sw.Write("=\"");
+
+                        sw.Write(oRS[i].ToString());
+
+                        if (type == typeof(String))
+                            sw.Write("\"");
+                        else if (oColumnNames[i] == "ean_code")  //always output ean codes as text to avoid conversion by excel to exponents
+                            sw.Write("\"");
+
+                        if (i < (FieldCount-1))
+                            sw.Write(",");
+
+                    }
+
+                    sw.Write(Environment.NewLine);
+
+                    //If you have reached the max number of rows you want to paint, then stop painting...
+                    if ((rowCount - StartRow) >= (MaxRows - 1))
+                        WriteRow = false;
+
+                }
+
+                rowCount++;
+
+            }
+
+            //Close the rs...
+            oRS.Close();
+
+            //Return the built csv...
+            return sw.GetStringBuilder();
+
+        }
+
+
+        #endregion
+
+    }
+}

GPS.XML.Utils/Utils/DBParams.cs

@@ -0,0 +1,247 @@
+using System.Data;
+using System.Data.Common;
+
+namespace com.cloudsoft.utils
+{
+    /// <summary>
+    /// Database Parameters class.
+    /// Allows parameters to be added to a DBHelper.
+    /// Can only be instatiated from a DBHelper.
+    /// JF 12/2007 - DBParams can now represent either an DbCommand or an DbCommand. Which one 
+    /// is decided when it is created by DBHelper. Once it is created though the client doesn't need to 
+    /// know which one it is dealing with.
+    /// </summary>
+    public class DBParams
+    {
+        /// <summary>
+        /// DataType enumerator. 
+        /// </summary>
+        /// <remarks>
+        /// <list type="bullet">
+        /// <item><term>VarChar</term><description> - Varchar (string)</description></item>
+        /// <item><term>Long</term><description> - Long integer</description></item>
+        /// <item><term>Double</term><description> - Double (float)</description></item>
+        /// <item><term>DateTime</term><description> - Date</description></item>
+        /// <item><term>LongVarChar</term><description> - Clob</description></item>
+        /// </list>
+        /// </remarks>
+        public enum DataType {
+            /// <summary>Varchar</summary>
+            VarChar,
+            /// <summary>Int</summary>
+            Int,
+            /// <summary>Long</summary>
+            Long,
+            /// <summary>Double</summary>
+            Double,
+            /// <summary>DateTime</summary>
+            DateTime,
+            /// <summary>LongVarChar</summary>
+            LongVarChar,
+            /// <summary>BLOB</summary>
+            BLOB,
+            /// <summary>Clob</summary>
+            Clob,
+            /// <summary>Xml</summary>
+            Xml
+        };
+
+        internal DbCommand Command;
+        /// <summary>
+        /// Oracle type equivalent of the oleType function. Returns the SqlDbType from the general
+        /// DBParams.DataType.
+        /// </summary>
+        /// <param name="eDT">A non-provider specific datatype.</param>
+        /// <returns>An SqlDbType.</returns>
+        private DbType _ODACType(DataType eDT)
+        {
+            switch (eDT)
+            {
+                case DataType.DateTime: return DbType.DateTime;
+                case DataType.Int: return DbType.Int32;
+                case DataType.Long: return DbType.Int64;
+                case DataType.Double: return DbType.Decimal;
+                case DataType.LongVarChar: return DbType.String;
+                case DataType.BLOB: return DbType.Binary;
+                case DataType.Clob: return DbType.String;
+                default: return DbType.String;
+            }
+        }
+
+        /// <summary>
+        /// DbCommand based DBParams constructor.
+        /// </summary>
+        /// <param name="oCommand">The DbCommand to wrap.</param>
+        internal DBParams(DbCommand oCommand)
+        {
+            Command = oCommand;
+        }
+
+        /// <summary>
+        /// Add Parameter method for the DbCommand
+        /// </summary>
+        /// <param name="zParamName"></param>
+        /// <param name="eDT"></param>
+        public void add(String zParamName, DataType eDT, object value)
+        {
+            //Command.Parameters.Add(new DbParameter(zParamName, _ODACType(eDT), value, System.Data.ParameterDirection.Input));
+        }
+
+        /// <summary>
+        /// Adds a Input Parameter to the DBHelper
+        /// </summary>
+        /// <param name="zParamName">Parameter Name</param>
+        /// <param name="eDT">DataType</param>
+        /// <param name="iSize">Size of the parameter</param>
+        /// <param name="oValue">Value of the Parameter</param>
+        public void add(String zParamName, DataType eDT, int iSize, Object oValue)
+        {
+            
+            //Set the size to 1 for longvarchars...
+            if ((eDT == DataType.LongVarChar) && (oValue == null))
+                iSize = 1;
+
+            //Adds the parameter...
+            DbParameter dbParam = Command.CreateParameter();
+            dbParam.ParameterName = zParamName;
+            dbParam.DbType = _ODACType(eDT);
+            dbParam.Size = iSize;
+            dbParam.Value = oValue;
+
+            Command.Parameters.Add(dbParam);
+
+        }
+
+        /// <summary>
+        /// Adds a Input Parameter to the DBHelper without a value
+        /// </summary>
+        /// <param name="zParamName">Parameter Name</param>
+        /// <param name="eDT">DataType</param>
+        /// <param name="iSize">Size of the parameter</param>
+        public void add(String zParamName, DataType eDT, int iSize)
+        {
+            //Add the parameter...
+            DbParameter dbParam = Command.CreateParameter();
+            dbParam.ParameterName = zParamName;
+            dbParam.DbType = _ODACType(eDT);
+            dbParam.Size = iSize;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          
+            Command.Parameters.Add(dbParam);
+        }
+
+        /// <summary>
+        /// Adds a Input Parameter to the DBHelper without a value or size
+        /// </summary>
+        /// <param name="zParamName">Parameter Name</param>
+        /// <param name="eDT">DataType</param>
+        /// <param name="iSize">Size of the parameter</param>
+        public void add(String zParamName, DataType eDT)
+        {
+            //Add the parameter...
+            var dbParam = Command.CreateParameter();
+            dbParam.ParameterName = zParamName;
+            dbParam.DbType = _ODACType(eDT);
+
+            Command.Parameters.Add(dbParam);
+        }
+
+
+        /// <summary>
+        /// Sets the input parameter value for a given parameter name
+        /// </summary>
+        /// <param name="zParamName">Parameter Name</param>
+        /// <param name="oValue">Value to set the input parameter to</param>
+        public void set(String zParamName, Object oValue)
+        {
+            //Set the parameter value...
+            Command.Parameters[zParamName].Value = oValue;
+        }
+
+        /// <summary>
+        /// Sets the input parameter value for a given parameter index
+        /// </summary>
+        /// <param name="index">Parameter Index</param>
+        /// <param name="oValue">Value to set the input parameter to</param>
+        public void set(int index, Object oValue)
+        {
+            //Set the parameter value...
+            Command.Parameters[index].Value = oValue;
+        }
+
+        public void set(string zParam, Object oValue, DbType iType)
+        {
+            DbParameter oParam = null;
+            if (Command.Parameters.Contains(zParam)) {
+                oParam = Command.Parameters[zParam];
+                oParam.Value = oValue;
+            }
+            else
+            {
+                oParam = Command.CreateParameter();
+                oParam.ParameterName = zParam;
+                if (iType != null)
+                    oParam.DbType = iType;
+                oParam.Value = oValue;
+                Command.Parameters.Add(oParam);
+            }
+            
+        }
+
+        /// <summary>
+        /// Adds an Output Parameter
+        /// </summary>
+        /// <param name="zParamName">Parameter Name</param>
+        /// <param name="eDT">Data Type</param>
+        /// <param name="iSize">Size of the parameter</param>
+        public void addOutput(String zParamName, DataType eDT, int iSize)
+        {
+            //Add the output parameter...
+            var dbParam = Command.CreateParameter();
+            dbParam.ParameterName = zParamName;
+            dbParam.DbType = _ODACType(eDT);
+            dbParam.Size = iSize;
+            dbParam.Direction = ParameterDirection.Output;
+        }
+
+        /// <summary>
+        /// Exposes the Parameters for the DbCommand.
+        /// </summary>
+        /// <returns>DbParameterCollection</returns>
+        public DbParameterCollection ODACParameters()
+        {
+            return Command.Parameters;
+        }
+
+        /// <summary>
+        /// Closes the appropriate underlying connection.
+        /// </summary>
+        public void CloseConnection()
+        {
+            Command.Connection.Close();
+        }
+
+        /// <summary>
+        /// Closes the appropriate underlying command.
+        /// </summary>
+        public void CloseCommand()
+        {
+            Command.Connection.Dispose();
+            Command.Dispose();
+        }
+
+        /// <summary>
+        /// Executes the appropriate underlying command.
+        /// </summary>
+        /// <returns>int</returns>
+        public int ExecuteNonQuery()
+        {
+            return Command.ExecuteNonQuery();
+        }
+
+
+        public DbCommand AsDbCommand()
+        {    
+            return Command;
+        }
+
+    }
+}

GPS.XML.Utils/Utils/ErrHelper.cs

@@ -0,0 +1,343 @@
+using Microsoft.Win32;
+using System.Diagnostics;
+using System.Text;
+
+namespace com.cloudsoft.utils
+{
+    /// <summary>
+    /// Base class for Business and data access options
+    /// </summary>
+    /// <remarks>
+    /// <example> Example code
+    /// <code>
+    /// public class Security_nTX : com.cloudsoft.utils.ErrHelper
+    /// {
+    ///    public Security_nTX() 
+    ///    {
+    ///        zgSystem = "GSK_SECURITY";
+    ///    }
+    ///    public String AuthoriseUserAction(String zPayload)
+    ///    {
+    ///        try
+    ///        {
+    ///            Security_DA oDA = new Security_DA();
+    ///            return oDA.AuthoriseUserAction(zPayload);
+    ///        }
+    ///       catch (Exception ex)
+    ///        {
+    ///            return handleError(ex);
+    ///        }
+    ///    }
+    /// </code>
+    /// </example>
+    /// </remarks>
+    public class ErrHelper
+    {
+
+        /// <summary>
+        /// Returns HTML for a WI Error
+        /// </summary>
+        /// <param name="oError">WI compliant error</param>
+        /// <returns>HTML for a WI Error</returns>
+        public string getParamsHTML(XMLHelper oError)
+        {
+            StringBuilder sbParams = new StringBuilder("<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\">");
+            sbParams.Append("<tr><th colspan=\"2\" align=\"left\">Form values</th></tr>");
+            if (oError.nodeCount("values/formvalues/value") <= 0)
+            {
+                sbParams.Append("<tr><td colspan=\"2\" align=\"left\">None</td></tr>");
+            }
+            else
+            {
+                foreach (XMLHelper value in oError.getNodes("values/formvalues/value"))
+                {
+                    if (value.getString("@id") != "__VIEWSTATE")
+                        sbParams.Append("<tr><td>" + value.getString("@id") + "</td><td>" + value.getValue() + "</td></tr>");
+                }
+            }
+            sbParams.Append("<tr><th colspan=\"2\" align=\"left\"><hr/></th></tr>");
+            sbParams.Append("<tr><th colspan=\"2\" align=\"left\">Querystring values</th></tr>");
+            if (oError.nodeCount("values/querystringvalues/value") <= 0)
+            {
+                sbParams.Append("<tr><td colspan=\"2\" align=\"left\">None</td></tr>");
+            }
+            else
+            {
+                foreach (XMLHelper value in oError.getNodes("values/querystringvalues/value"))
+                {
+                    if (value.getString("@id") != "__VIEWSTATE")
+                        sbParams.Append("<tr><td>" + value.getString("@id") + "</td><td>" + value.getValue() + "</td></tr>");
+                }
+            }
+            sbParams.Append("</table>");
+            return sbParams.ToString();
+        }
+
+        /// <summary>
+        /// Logs an error using WI mechanisms, emailing if configured to do so
+        /// </summary>
+        /// <param name="oError">WI compliant error</param>
+        public void logError(XMLHelper oError)
+        {
+
+            short category = 4;
+            int id = 1;
+
+            // Log the entry to the event log...
+            throw new Exception(oError.getString("message"));
+            // EventLog.WriteEntry(zgSystem, oError.getString("message") + " \rPath: " + oError.getString("path") + " \rUser: " + oError.getString("user"), EventLogEntryType.Error, id, category, ba);
+        }
+
+        /// <summary>
+        /// Enum for Error Types
+        /// </summary>
+        /// <remarks>
+        /// <list type="bullet">
+        /// <item><term>System</term><description> - System Error</description></item>
+        /// <item><term>Business</term><description> - Business Error</description></item>
+        /// <item><term>Information</term><description> - Information (not an error)</description></item>
+        /// </list>
+        /// </remarks>
+        public enum ErrorType {
+            /// <summary>System</summary> 
+            System,
+            /// <summary>Business</summary>
+            Business,
+            /// <summary>Information</summary>
+            Information
+        };
+
+        /// <summary>
+        /// The System. Used to log events
+        /// </summary>
+        private String _zgSystem;
+
+        public String zgSystem
+        {
+            get
+            {
+                return _zgSystem;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ErrHelper"/> class.
+        /// </summary>
+        public ErrHelper()
+            : this("GSK")
+        { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ErrHelper"/> class with a system.
+        /// </summary>
+        public ErrHelper(String zSystem)
+        {
+            _zgSystem = zSystem;
+        }
+
+        /// <summary>
+        /// Handles the error.
+        /// </summary>
+        /// <param name="ex">The Exception</param>
+        /// <returns>Nothing , but rethrows the error with formatted xml as the error message</returns>
+        public String handleError(Exception ex)
+        {
+            ErrorType et = ErrorType.System;
+            if (ex.Source == "Oledb")
+                et = ErrorType.Business;
+            return handleError(ex, et);
+        }
+
+        /// <summary>
+        /// Handles the error.
+        /// </summary>
+        /// <param name="ex">The Exception</param>
+        /// <param name="et">The error type. <see cref="ErrorType"/></param>
+        /// <returns>Nothing , but rethrows the error with formatted xml as the error message</returns>
+        public String handleError(Exception ex, ErrorType et)
+        {
+
+            //WADS: Detailed exception info no longer given to the user...
+            throw new Exception(et + " error : " + ex.Message);
+
+            //XMLHelper oError = new XMLHelper();
+            //if (oError.load(ex.Message) == false)
+            //{
+            //    String zType = "SYSTEMERROR";
+            //    switch (et)
+            //    {
+            //        case ErrorType.Business:
+            //            zType = "BUSINESSEXCEPTION";
+            //            break;
+            //        case ErrorType.Information:
+            //            zType = "INFORMATION";
+            //            break;
+            //    }
+            //    StackTrace oST = new StackTrace();
+            //    int iFrame = 1;
+            //    String zMethod = oST.GetFrame(iFrame).GetMethod().Name;
+            //    while (zMethod == "throwError" || zMethod == "handleError" || zMethod == "validatePayload")
+            //        zMethod = oST.GetFrame(iFrame++).GetMethod().Name;
+            //    oError.createRoot("gskutils");
+            //    oError = oError.appendNode("error");
+            //    oError.appendAttribute("time", DateTime.Now.ToString("dd-MMM-yyyy hh:mm:ss"));
+            //    oError.appendAttribute("type", zType);
+            //    oError.appendAttribute("class", this.GetType().ToString());
+            //    oError.appendAttribute("method", zMethod);
+            //    oError.appendNode("source", (ex.Source == null ? this.GetType().ToString() : ex.Source));
+            //    oError.appendNode("description", ex.Message);
+            //    oError.appendNode("stack_trace", ex.StackTrace);
+            //    if (zType == "SYSTEMERROR")
+            //        writeEvent(zgSystem, oError.getRootXML(), et);
+            //}
+            ////WADS: Error detail...
+            //logError(oError);
+            //throw new Exception("WI Handled error has occured. Please report to the helpdesk.");
+        }
+
+        /// <summary>
+        /// Throws a Business error.
+        /// </summary>
+        /// <param name="zMessage">The Business Error message.</param>
+        public void throwError(String zMessage)
+        {
+            throwError(zMessage, ErrorType.Business);
+        }
+        
+        /// <summary>
+        /// Throws an error.
+        /// </summary>
+        /// <param name="zMessage">The error message.</param>
+        /// <param name="et">The error type. <see cref="ErrorType"/></param>
+        public void throwError(String zMessage, ErrorType et)
+        {
+            handleError(new Exception(zMessage), et);
+        }
+        /// <summary>
+        /// Writes a debug message using the win32 api
+        /// </summary>
+        /// <param name="zMessage">The  message.</param>
+        public void debugMsg(Object zMessage)
+        {
+            String zMethod = new StackTrace().GetFrame(1).GetMethod().Name;
+            Debug.Write(this.GetType().Name + "." +  zMethod + " : " + zMessage);
+        }
+
+        public XMLHelper validatePayload(String zPayload)
+        {
+
+            XMLHelper domToLoad = new XMLHelper();
+
+            if (domToLoad.load(zPayload) == false)
+                throwError("Invalid Payload. XML is invalid");
+
+            // Get the calling Method
+            String zMethod = new StackTrace().GetFrame(1).GetMethod().Name;
+
+            return validatePayload(domToLoad, zMethod);
+
+        }
+
+        public XMLHelper validatePayload(XMLHelper oPayload)
+        {
+            // Get the calling Method
+            String zMethod = new StackTrace().GetFrame(1).GetMethod().Name;
+            return validatePayload(oPayload, zMethod);
+        }
+
+        /// <summary>
+        /// Validates the payload.
+        /// </summary>
+        /// <param name="zPayload">The payload.</param>
+        /// <returns>Returns an XML Helper DOM of the Payload</returns>
+        private XMLHelper validatePayload(XMLHelper oPayload, String zMethod)
+        {
+
+            XMLHelper domToLoad = oPayload;
+
+            String zRequestType = domToLoad.getString("/request/@type");
+            
+            // Check to see that payload is right for method
+            if (zRequestType == "")
+                throwError("The request does not have a type attribute");
+
+            // Check to see that payload is right for method
+            if (zMethod.ToUpper() != zRequestType.ToUpper() && (zRequestType.ToUpper() != "SYSTEM"))
+                throwError("The payload sent to the method " + zMethod + " is invalid. Not equal to " + zRequestType);
+        
+            // Build security payload xml
+            String zUsername = domToLoad.getString("mud_id");
+
+            if (domToLoad.getString("@sec") != "off")
+            {
+                XMLHelper oRequest = new XMLHelper().createStandardRequest("ValidatePayload", zUsername, domToLoad.getString("system"));
+                oRequest.appendNode("resource", zMethod.ToUpper());
+                oRequest.appendNode("action", "true");
+
+                // Create instance of security object
+                //Security_nTX oSecurity = new Security_nTX();
+
+                //// Check user rights
+                //XMLHelper oResponse = new XMLHelper();
+                //oResponse.load(oSecurity.AuthoriseUserAction(oRequest.getRootXML()));
+
+                //if (oResponse.getString("poReturnValue").StartsWith("TRUE") == false)
+                //    throwError("User '" + zUsername + "' does not have rights to perform the action '" + zMethod + "'.");
+                ////throwError("Request : " + oRequest.getXML() + " Response : " + oResponse.getXML());
+            }
+        
+            //Create System Audit
+            if (zRequestType != "SYSTEM")
+            {
+                //Set oAudit = CreateObject("GSKUtils.Auditor")
+                //If Len(zpPayload) < 2000 Then
+                    //oAudit.SystemAudit "CIMS", "Unknown", zpMethod, zUsername, zpPayload
+                //Else
+                  //  oAudit.SystemAudit "CIMS", "Unknown", zpMethod, zUsername
+                //End If
+            }
+            
+            return domToLoad;
+
+        }
+
+        /// <summary>
+        /// Writes to the event log.
+        /// </summary>
+        /// <param name="zSource">The source.</param>
+        /// <param name="zMessage">The message.</param>
+        /// <param name="et">The Error type</param>
+        private void writeEvent(String zSource, String zMessage, ErrorType et)
+        {
+            RegistryKey kLM = Registry.LocalMachine;
+            String zLogDir;
+            lock (kLM)
+            {
+                RegistryKey kSystem = kLM.OpenSubKey("Software\\GlaxoWellcome\\" + zSource);
+                zLogDir = (String)kSystem.GetValue("ErrorLog");
+                if (zLogDir == null)
+                {
+                    kSystem = kLM.OpenSubKey("Software\\GlaxoWellcome\\UN");
+                    zLogDir = (String)kSystem.GetValue("ErrorLog");
+                }
+            }
+
+            if (zLogDir != null)
+            {
+                try
+                {
+                    StreamWriter osw;
+                    FileInfo ofi = new FileInfo(zLogDir + "\\error.log");
+                    if (!ofi.Exists)
+                        osw = ofi.CreateText();
+                    else
+                        osw = ofi.AppendText();
+
+                    osw.WriteLine(zMessage);
+                    osw.Close();
+                }
+                catch { }
+            }
+        }
+    }
+}

GPS.XML.Utils/Utils/XMLHelper.cs

@@ -0,0 +1,1397 @@
+using System.Collections.Specialized;
+using System.Data.Common;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Xml;
+using System.Xml.Schema;
+using System.Xml.XPath;
+using System.Xml.Xsl;
+
+namespace com.cloudsoft.utils
+{
+
+    /// <summary>
+    /// Class contains methods for constructing and querying XML doms
+    /// </summary>
+    /// 
+    public class XMLHelper
+    {
+
+        // Declare module level variables
+        /// <summary>The Node that this XMLHelper wraps</summary>
+        protected XmlNode omNode;
+        protected Boolean isValidXml = true;
+        public String ValidationError;
+        private static String _QUOTE = "\"";
+        private Regex _DatePattern = null;
+        private Regex _DoublePattern = null;
+        internal DbConnection _con = null;
+
+        #region Constructors
+
+        /// <summary>Creates a new instance of XMLHelper </summary>
+        public XMLHelper()
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of XMLHelper with the base node set
+        /// </summary>
+        /// <param name="zRoot">The root node to create or an XML Document to load</param>
+        public XMLHelper(String zRoot)
+        {
+            if (zRoot.Contains("<") || zRoot.Contains("&#60;") || zRoot.Contains("\\"))
+                //WADS: Cross site scripting...
+                load(zRoot);
+            else
+                //WADS: XPath Injection...
+                createRoot(zRoot);
+        }
+
+        public XMLHelper(StringBuilder zRoot)
+        {
+            load(zRoot);
+        }
+
+        public XMLHelper(Stream stream)
+        {
+            load(stream);
+        }
+
+        /// <summary>
+        /// Creates a new instance of XMLHelper with the base node set
+        /// </summary>
+        /// <param name="oNode">The base node to set</param>
+        public XMLHelper(XmlNode oNode)
+        {
+            omNode = oNode;
+        }
+
+        /// <summary>
+        /// Creates a new instance of XMLHelper with the base node set to the first child of the Document
+        /// </summary>
+        /// <param name="oDoc">Document to base this XMLHelper on</param>
+        public XMLHelper(XmlDocument oDoc)
+        {
+            omNode = (XmlNode)oDoc.DocumentElement;
+        }
+
+        #endregion
+
+        #region IO & Save Methods
+
+        /// <summary>
+        /// Saves the dom to the specified path. Always overwrites anything already there.
+        /// </summary>
+        /// <param name="path">The path to save to.</param>
+        public void SaveAs(String path)
+        {
+
+            try
+            {
+                //Overwrite any existing files...
+                FileInfo fi = new FileInfo(path);
+                if (fi.Exists)
+                    fi.Delete();
+            }
+            catch
+            {
+                //If you can't delete the file then don't try and overwrite it...
+                return;
+            }
+
+            StreamWriter sw = new StreamWriter(path);
+            try
+            {
+
+                //Set up a stream...
+                sw.AutoFlush = true;
+
+                //Write to the stream and close it...
+                sw.WriteLine("<?xml version=\"1.0\" encoding=\"utf-8\" ?>");
+                sw.Write(this.getXML());
+
+            }
+            finally
+            {
+                sw.Close();
+                sw.Dispose();
+            }
+
+        }
+
+        #endregion
+
+        #region "Helper" methods
+
+        /// <summary>
+        /// Creates a Standard Request DOM
+        /// </summary>
+        /// <param name="zType">The type of request</param>
+        /// <param name="zMudID">The mud id</param>
+        /// <param name="zSystem">The system id</param>
+        /// <returns></returns>
+        public XMLHelper createStandardRequest(String zType, String zMudID, String zSystem)
+        {
+            return createStandardRequest(zType, zMudID, zSystem, zMudID);
+        }
+
+        /// <summary>
+        /// Handles delegation
+        /// </summary>
+        /// <param name="zType"></param>
+        /// <param name="zMudID"></param>
+        /// <param name="zSystem"></param>
+        /// <param name="UserLogon"></param>
+        /// <returns></returns>
+        public XMLHelper createStandardRequest(String zType, String zMudID, String zSystem, String UserLogon)
+        {
+            this.createRoot("request");
+            this.appendAttribute("type", zType);
+            this.appendNode("mud_id", zMudID);
+            this.appendNode("system", zSystem);
+
+            string zDeligateUser = UserLogon;
+            string[] aSplit = zDeligateUser.Split("\\".ToCharArray());
+            zDeligateUser = aSplit[aSplit.Length - 1].ToUpper();
+
+            if (zMudID != zDeligateUser)
+                this.appendNode("delegate_id", zDeligateUser);
+
+            return this;
+        }
+
+        #endregion
+
+        #region Dom Manipulation
+
+        /// <summary>
+        /// Creates the root Node
+        /// </summary>
+        /// <param name="zRootName">The name of the root node</param>
+        public void createRoot(String zRootName)
+        {
+            //WADS: XPath Injection...
+            this.load("<" + zRootName + "/>");
+        }
+
+        /// <summary>
+        /// Appends a node to the dom
+        /// </summary>
+        /// <param name="vNodeName">The name of the new node</param>
+        /// <returns>Returns an XMLHelper of the new Node</returns>
+        public XMLHelper appendNode(String vNodeName)
+        {
+            XmlDocument oDoc = omNode.OwnerDocument;
+            XmlNode oNewNode = oDoc.CreateElement(vNodeName);
+            omNode.AppendChild(oNewNode);
+            XMLHelper oHelper = new XMLHelper(oNewNode);
+            return oHelper;
+        }
+
+        /// <summary>
+        /// Appends a node to the dom and sets it's value
+        /// </summary>
+        /// <param name="vNodeName">The name of the new node</param>
+        /// <param name="zValue">The value to set the new node</param>
+        /// <returns>Returns the XMLHelper for the new node</returns>
+        public XMLHelper appendNode(String vNodeName, Object zValue)
+        {
+            XmlDocument oDoc = omNode.OwnerDocument;
+            XmlNode oNewNode = oDoc.CreateElement(vNodeName);
+            oNewNode.AppendChild(oDoc.CreateTextNode(zValue == null ? "" : zValue.ToString()));
+            omNode.AppendChild(oNewNode);
+            XMLHelper oHelper = new XMLHelper(oNewNode);
+            return oHelper;
+        }
+
+        /// <summary>
+        /// Appends an XMLHelper dom
+        /// </summary>
+        /// <param name="oDOM">The DOM to append to this DOM</param>
+        /// <returns>Returns the XMLHelper for the new node</returns>
+        public XMLHelper appendNode(XMLHelper oDOM)
+        {
+            XmlNode oNew = omNode.OwnerDocument.ImportNode(oDOM.omNode, true);
+            omNode.AppendChild(oNew);
+            return new XMLHelper(oNew);
+        }
+
+        /// <summary>
+        /// Appends a NameValueCollection to the DOM as Nodes
+        /// </summary>
+        /// <param name="oCol">The DOM to append to this DOM</param>
+        public void appendNode(NameValueCollection oCol)
+        {
+            // Iterate through the collection and add
+            // each name value pair to the dom
+            for (int i = 0; i < oCol.Count; i++)
+            {
+                String zName = oCol.GetKey(i);
+                String[] pValues = oCol.GetValues(i);
+                for (int j = 0; j < pValues.Length; j++)
+                    appendNode(zName, pValues[j]);
+            }
+        }
+
+        /// <summary>
+        /// Appends an array of XMLHelpers
+        /// </summary>
+        /// <param name="oNodes">The Nodelist to append to the existing DOM</param>
+        public void appendNode(XMLHelper[] oNodes)
+        {
+            for (int i = 0; i < oNodes.Length; i++)
+                appendNode(oNodes[i]);
+        }
+
+        /// <summary>
+        /// Appends an attribute to the dom and sets it's value
+        /// </summary>
+        /// <param name="zNodeName">The name of the new node</param>
+        /// <param name="zValue">The value to set the new node</param>
+        public void appendAttribute(String zNodeName, String zValue)
+        {
+            //        Attr oAttr = omNode.getOwnerDocument().createAttribute(zNodeName);
+            //        oAttr.setNodeValue(zValue);
+            //        omNode.appendChild(oAttr);
+            XmlElement oNode = (XmlElement)omNode;
+            oNode.SetAttribute(zNodeName, zValue);
+        }
+
+        /// <summary>
+        /// Retrieved the root node of a XMLHelper dom
+        /// </summary>
+        /// <returns>Returns the Root Node for this XMLHelper DOM</returns>
+        public XMLHelper getRootNode()
+        {
+            return new XMLHelper(omNode.OwnerDocument);
+        }
+
+        public void appendXPathNode(String zXPath, String zValue)
+        {
+            appendXPathNode(zXPath, zValue, true);
+        }
+
+        /// <summary>
+        /// Appends a node/attribute based on an XPath (like alias names in SQL)
+        /// </summary>
+        /// <param name="zXPath">The name of the new node/attribute in XPath syntax</param>
+        /// <param name="zValue">The value to set the new node</param>
+        public void appendXPathNode(String zXPath, String zValue, Boolean AlwaysAddNewNode)
+        {
+            try
+            {
+                int i;
+                XmlNode oOrig = omNode;
+                // Split the Name by "/"
+                String[] arrNodes = zXPath.Split(new char[] { '/' });
+                for (i = 0; i < arrNodes.Length - 1; i++)
+                {
+                    XmlNode oNode = omNode.SelectSingleNode(arrNodes[i]);
+                    if (oNode == null)
+                        omNode = appendNode(arrNodes[i]).omNode;
+                    else
+                        omNode = oNode;
+                }
+                if (arrNodes[i].StartsWith("@"))
+                    appendAttribute(arrNodes[i].Substring(1), zValue);
+                else
+                {
+                    if (AlwaysAddNewNode)
+                    {
+                        appendNode(arrNodes[i], zValue);
+                    }
+                    else
+                    {
+                        if (this.nodeCount(arrNodes[i]) > 0)
+                        {
+                            this.getNode(arrNodes[i]).setValue(zValue);
+                        }
+                        else
+                        {
+                            appendNode(arrNodes[i], zValue);
+                        }
+                    }
+                }
+                omNode = oOrig;
+            }
+            catch (Exception ex)
+            {
+                System.Console.WriteLine(ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Removes a node given the nodename
+        /// </summary>
+        /// <param name="zNodeName">The name of node to remove</param>
+        public void removeNode(String zNodeName)
+        {
+            try
+            {
+                XmlNode oTempNode = omNode.SelectSingleNode(zNodeName);
+                if (oTempNode != null)
+                    oTempNode.ParentNode.RemoveChild(oTempNode);
+            }
+            catch
+            {
+                // Do nothing if we can't remove the node
+            }
+
+        }
+
+        #endregion
+
+        #region Serialisation
+
+        /// <summary>
+        /// Searalises the current tree from the current Node to a Writer (like Resonse.Output)
+        /// </summary>
+        /// <param name="oWriter">The Writer to write the XML to (eg. Resonse.Output)</param>
+        public void serializeNode(TextWriter oWriter)
+        {
+            try
+            {
+                serializeNode(omNode, oWriter);
+            }
+            catch (Exception ex)
+            {
+                System.Console.WriteLine(ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Serializes the node.
+        /// </summary>
+        /// <param name="oNode">The node.</param>
+        /// <param name="oWriter">The writer.</param>
+        private void serializeNode(XmlNode oNode, TextWriter oWriter)
+        {
+            try
+            {
+                oWriter.Write(oNode.OuterXml);
+            }
+            catch (Exception ex)
+            {
+                System.Console.WriteLine(ex.Message);
+            }
+        }
+
+        /// <summary>
+        /// Serializes the node.
+        /// </summary>
+        /// <param name="oNode">The node.</param>
+        /// <returns>An XML String</returns>
+        private String serializeNode(XmlNode oNode)
+        {
+            try
+            {
+                return (oNode.OuterXml);
+            }
+            catch (Exception ex)
+            {
+                System.Console.WriteLine(ex.Message);
+                return ("");
+            }
+        }
+
+        public String getJSON()
+        {
+            StringWriter stringOut = new StringWriter();
+            getJSON(stringOut);
+            return (stringOut.ToString());
+        }
+        public void getJSON(TextWriter oOut)
+        {
+            oOut.Write("{");
+            getJSON(omNode.OwnerDocument.FirstChild, false, oOut);
+            oOut.Write("}");
+        }
+
+        private void getJSON(XmlNode oNode, Boolean isArray, TextWriter oOut)
+        {
+            String zName = oNode.Name;
+            if (zName.Equals("#text")) zName = "$";
+            if (!isArray)
+                oOut.Write(_QUOTE + zName + _QUOTE + ":");
+            if (isJSONArray(oNode.ChildNodes))
+            {
+                oOut.Write("[");
+                getJSON(oNode.ChildNodes, true, oOut);
+                oOut.Write("]");
+            }
+            else if (oNode.NodeType == XmlNodeType.Attribute)
+            {
+                oOut.Write(getJSONValue(oNode.Value));
+            }
+            else if (!oNode.HasChildNodes && (oNode.Attributes == null || oNode.Attributes.Count == 0))
+            {
+                if (oNode.Value == null)
+                    oOut.Write("null");
+                else
+                    oOut.Write(getJSONValue(oNode.Value));
+            }
+            else if (oNode.Attributes.Count == 0 && oNode.ChildNodes.Count == 1 && !oNode.FirstChild.HasChildNodes)
+            {
+                oOut.Write(getJSONValue(oNode.FirstChild.Value));
+            }
+            else
+            {
+                oOut.Write("{");
+                getJSON(oNode.Attributes, oOut);
+                if (oNode.Attributes.Count > 0 && oNode.ChildNodes.Count > 0)
+                    oOut.Write(",");
+                getJSON(oNode.ChildNodes, false, oOut);
+                oOut.Write("}");
+            }
+        }
+        private void getJSON(XmlNodeList oNodeList, Boolean isArray, TextWriter oOut)
+        {
+            for (int i = 0; i < oNodeList.Count; i++)
+            {
+                XmlNode oNode = oNodeList.Item(i);
+                if (i > 0) oOut.Write(",");
+                getJSON(oNode, isArray, oOut);
+            }
+        }
+        private void getJSON(XmlAttributeCollection oNodeMap, TextWriter oOut)
+        {
+            for (int i = 0; i < oNodeMap.Count; i++)
+            {
+                XmlNode oNode = oNodeMap.Item(i);
+                if (i > 0) oOut.Write(",");
+                getJSON(oNode, false, oOut);
+            }
+        }
+        private String getJSONValue(String zValue)
+        {
+            zValue = zValue.Trim();
+            if (DatePattern().IsMatch(zValue))
+            {
+                DateTime matchDate = DateTime.Now;
+                try { matchDate = DateTime.Parse(zValue); }
+                catch (Exception ex) { }
+                String ret = "new Date(" + matchDate.Year + "," + (matchDate.Month - 1) + "," + matchDate.Day;
+                if (zValue.Length > 11)
+                    ret += "," + matchDate.Hour + "," + matchDate.Minute + "," + matchDate.Second;
+                ret += ")";
+                return ret;
+            }
+            else if (zValue.Length <= 10)
+            {
+                try { return int.Parse(zValue).ToString(); }
+                catch (Exception ex) { }
+                if (DoublePattern().IsMatch(zValue))
+                    return zValue;
+                //try { return Double.Parse(zValue).ToString();}
+                //catch (Exception ex) {}
+            }
+            return _QUOTE + zValue.Replace("\\", "\\\\").Replace("\"", "\\\"") + _QUOTE;
+        }
+
+        private Boolean isJSONArray(XmlNodeList oNodeList)
+        {
+            if (oNodeList.Count < 1 || (oNodeList.Count == 1 && (oNodeList.Item(0).Name + "s") != oNodeList.Item(0).ParentNode.Name)) return (false);
+            String zName = oNodeList.Item(0).Name;
+            for (int i = 0; i < oNodeList.Count; i++)
+            {
+                if (!oNodeList.Item(i).Name.Equals(zName))
+                    return (false);
+            }
+            return (true);
+        }
+        private Regex DatePattern()
+        {
+            if (_DatePattern == null)
+            {
+                _DatePattern = new Regex("^(([0-9])|([0-2][0-9])|([3][0-1]))-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\\d{4}.*", RegexOptions.IgnoreCase);
+            }
+            return _DatePattern;
+        }
+        private Regex DoublePattern()
+        {
+            if (_DoublePattern == null)
+            {
+                _DoublePattern = new Regex("^[-+]?[0-9]*\\.?[0-9]+$");
+            }
+            return _DoublePattern;
+        }
+
+        #endregion
+
+        #region Load Methods
+
+        /// <summary>
+        /// Loads a string into the DOM or a file. Either an XML string or a file location may be used
+        /// </summary>
+        /// <param name="zXML">Either the XML as a string or a file location</param>
+        /// <returns>Boolean indicating success or failure</returns>
+        public Boolean load(String zXML)
+        {
+            try
+            {
+                XmlDocument oDOM = new XmlDocument();
+                if (zXML.StartsWith("<") || zXML.StartsWith("&#60;"))
+                    //WADS: XPath Injection...
+                    oDOM.LoadXml(zXML);
+                else
+                    //WADS: XPath Injection...
+                    oDOM.Load(zXML);
+                omNode = (XmlNode)oDOM.DocumentElement;
+                return true;
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Can't load dom. Error: " + ex.Message);
+            }
+        }
+
+        public Boolean load(Stream stream)
+        {
+            try
+            {
+                XmlDocument oDOM = new XmlDocument();
+                oDOM.Load(stream);
+                omNode = (XmlNode)oDOM.DocumentElement;
+                return true;
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Can't load dom. Error: " + ex.Message);
+            }
+        }
+
+        public Boolean load(StringBuilder zXML)
+        {
+            try
+            {
+                StringReader sr = new StringReader(zXML.ToString());
+                XmlReader xr = XmlReader.Create(sr);
+                XmlDocument oDOM = new XmlDocument();
+                oDOM.Load(xr);
+                omNode = (XmlNode)oDOM.DocumentElement;
+                return true;
+            }
+            catch (Exception ex)
+            {
+                throw new Exception("Can't load dom. Error: " + ex.Message);
+            }
+        }
+        public Boolean loadTSV(String zPath)
+        {
+            try
+            {
+                // Create an instance of StreamReader to read from a file.
+                // The using statement also closes the StreamReader.
+                this.createRoot("response");
+                XMLHelper oRows = this.appendNode("rows");
+                using (StreamReader sr = new StreamReader(zPath))
+                {
+                    String[] aHeader = null;
+                    String line;
+                    // Read and display lines from the file until the end of 
+                    // the file is reached.
+                    while ((line = sr.ReadLine()) != null)
+                    {
+                        // Get the header if we don't have it
+                        if (aHeader == null)
+                        {
+                            aHeader = line.Split('\t');
+                        }
+                        else
+                        {
+                            String[] aFields = line.Split('\t');
+                            int i = 0;
+                            XMLHelper oRow = oRows.appendNode("row");
+                            foreach (String zHeader in aHeader)
+                                oRow.appendNode(zHeader, aFields[i++]);
+                        }
+                    }
+                }
+                return true;
+            }
+            catch (Exception e)
+            {
+                // Let the user know what went wrong.
+                throw new Exception("The file could not be read: " + e.Message);
+            }
+        }
+        #endregion
+
+        #region Get and Set Methods
+
+        /// <summary>
+        /// Retrieved the child nodes an XMLHelper dom
+        /// </summary>
+        /// <returns>Returns the Child nodes as an array</returns>
+        public XMLHelper[] getChildNodes()
+        {
+            XmlNodeList oNodes = omNode.ChildNodes;
+            XMLHelper[] arrNodes = new XMLHelper[oNodes.Count];
+            for (int i = 0; i < oNodes.Count; i++)
+                arrNodes[i] = new XMLHelper(oNodes.Item(i));
+            return arrNodes;
+        }
+        public XMLHelper getFirstChild()
+        {
+            return new XMLHelper(omNode.FirstChild);
+        }
+
+        public DateTime getSQLDate(String zXPath)
+        {
+            return getDate(zXPath);
+
+        }
+        public DateTime getSQLDateTime(String zXPath)
+        {
+            return getDate(zXPath);
+        }
+        /// <summary>
+        /// Gets the XML of the current node as a string
+        /// </summary>
+        /// <returns>Returns the XML of the current node as a string</returns>
+        public String getXML()
+        {
+            return serializeNode(omNode);
+        }
+
+        /// <summary>
+        /// Gets the InnerXML of the current node as a string
+        /// </summary>
+        /// <returns>Returns the InnerXML of the current node as a string</returns>
+        public String getInnerXML()
+        {
+            return omNode.InnerXml;
+        }
+
+        /// <summary>
+        /// Gets the XML of the root node as a string
+        /// </summary>
+        /// <returns>Returns the XML of the root node as a string</returns>
+        public String getRootXML()
+        {
+            return omNode.OwnerDocument.OuterXml;
+        }
+
+        /// <summary>
+        /// Get the parent XMLHelper
+        /// </summary>
+        /// <returns>Returns the Parent node as an XMLHelper object</returns>
+        public XMLHelper getParent()
+        {
+            XMLHelper oHelper = new XMLHelper(omNode.ParentNode);
+            return oHelper;
+        }
+
+        /// <summary>
+        /// Returns the Name of a node or element
+        /// </summary>
+        /// <returns>The node name of the current node</returns>
+        public String getName()
+        {
+            try
+            {
+                return omNode.Name;
+            }
+            catch (Exception)
+            {
+
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element
+        /// JF 12/2007 - Added a check for a null valued XMLHelper (with a null omNode)
+        /// rather than relying on the exception handler.
+        /// </summary>
+        /// <returns>The nodevalue of the current node</returns>
+        public String getValue()
+        {
+            if (omNode != null)
+            {
+                try
+                {
+                    return omNode.InnerText;
+                }
+                catch (Exception)
+                {
+                    return "";
+                }
+            }
+            else
+            {
+                return "";
+            }
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as a string
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a string</returns>
+        public String getValue(String zXPath)
+        {
+            return getNode(zXPath).getValue();
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as a string
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a string</returns>
+        public String getString(String zXPath)
+        {
+            return getValue(zXPath);
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as a long
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a long</returns>
+        public long getLong(String zXPath)
+        {
+            try
+            {
+                return Convert.ToInt64(getValue(zXPath).Trim());
+
+            }
+            catch (Exception)
+            {
+
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as an int
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as an int</returns>
+        public int getInt(String zXPath)
+        {
+            try
+            {
+                String value = getValue(zXPath).Trim();
+                if (value.Length > 0)
+                {
+                    return Convert.ToInt32(value);
+                }
+                else
+                {
+                    return 0;
+                }
+
+            }
+            catch (Exception)
+            {
+
+                return 0;
+            }
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as a double
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a double</returns>
+        public double getDouble(String zXPath)
+        {
+            try
+            {
+                return Convert.ToDouble(getValue(zXPath).Trim());
+            }
+            catch
+            {
+                return 0.0;
+            }
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as a DateTime Object
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a DateTime Object</returns>
+        public DateTime getDate(String zXPath)
+        {
+            DateTime d = DateTime.MinValue;
+            try
+            {
+                DateTime.TryParse(getValue(zXPath).Trim(), out d);
+            }
+            catch { }
+            return d;
+
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as a Boolean
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a Boolean</returns>
+        public Boolean getBoolean(String zXPath)
+        {
+            String zVal = getValue(zXPath).ToUpper();
+            return (zVal.Equals("Y") || zVal.Equals("YES") || zVal.Equals("TRUE"));
+        }
+
+        /// <summary>
+        /// Returns the value of a node or element as either Y or N
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>The nodevalue of the Node found as a Boolean</returns>
+        public String getYN(String zXPath)
+        {
+            return (getBoolean(zXPath) ? "Y" : "N");
+        }
+        /// <summary>
+        /// Returns an XMLHelper for a XPath
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>XMLHelper for a XPath</returns>
+        public XMLHelper getNode(String zXPath)
+        {
+            XmlNode oNode;
+            try
+            {
+                oNode = omNode.SelectSingleNode(zXPath);
+                return new XMLHelper(oNode);
+            }
+
+            catch
+            {
+                throw new Exception("Can't get node for xpath: " + zXPath);
+            }
+        }
+
+        /// <summary>
+        /// Returns an Array of XMLHelper objects for a XPath
+        /// </summary>
+        /// <param name="zXPath">A valid XPath to find a node</param>
+        /// <returns>Array of XMLHelper object for a XPath</returns>
+        public XMLHelper[] getNodes(String zXPath)
+        {
+            try
+            {
+                XmlNodeList oNodes = omNode.SelectNodes(zXPath);
+                XMLHelper[] arrNodes = new XMLHelper[oNodes.Count];
+                for (int i = 0; i < oNodes.Count; i++)
+                    arrNodes[i] = new XMLHelper(oNodes.Item(i));
+                return arrNodes;
+
+            }
+            catch (Exception ex)
+            {
+                System.Console.WriteLine(ex.Message);
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets a CSV string given an XPath
+        /// </summary>
+        /// <param name="zXPath">The XPath.</param>
+        /// <returns>A CSV String</returns>
+        public String getCSV(String zXPath)
+        {
+            StringWriter oSW = new StringWriter();
+            XmlNodeList oNodes = omNode.SelectNodes(zXPath);
+            for (int i = 0; i < oNodes.Count; i++)
+            {
+                if (i > 0)
+                    oSW.Write(',');
+                oSW.Write(oNodes[i].InnerText);
+            }
+            return oSW.ToString();
+        }
+
+        /// <summary>
+        /// Sets a Nodes value
+        /// </summary>
+        /// <param name="zNodeName">The name of the node to set</param>
+        /// <param name="zValue">The value to set the node</param>
+        public void setNode(String zNodeName, String zValue)
+        {
+            removeNode(zNodeName);
+            appendNode(zNodeName, zValue);
+        }
+
+        /// <summary>
+        /// Sets a Nodes value
+        /// </summary>
+        /// <param name="zNodeName">The name of the node to set</param>
+        /// <param name="zValue">The value to set the node</param>
+        public void setValue(String zValue)
+        {
+            omNode.InnerText = zValue;
+        }
+
+        /// <summary>
+        /// Sets an attribute value
+        /// </summary>
+        /// <param name="zNodeName">The name of the attribute to set</param>
+        /// <param name="zValue">The value to set the attribute</param>
+        public void setAttribute(String zAttributeName, String zValue)
+        {
+            omNode.Attributes[zAttributeName].Value = zValue;
+        }
+
+        public void setAttribute(String zAttributeName, Int32 iValue)
+        {
+            omNode.Attributes[zAttributeName].Value = iValue.ToString();
+        }
+        /// <summary>
+        /// Gets the numbers of rows given an XPath
+        /// </summary>
+        /// <param name="zXPath">The Xpath to get the nodecount for</param>
+        /// <returns>The number of nodes for the given Xpath</returns>
+        public int nodeCount(String zXPath)
+        {
+            try
+            {
+                XmlNodeList oNodes = omNode.SelectNodes(zXPath);
+                return (oNodes.Count);
+            }
+            catch
+            {
+                return 0;
+            }
+        }
+
+        public XPathNodeIterator getIterator(String sourceNodePath)
+        {
+            XPathNavigator nav = omNode.CreateNavigator();
+            XPathExpression expression = nav.Compile(sourceNodePath);
+            return nav.Select(expression);
+        }
+
+        #endregion
+
+        #region Testing
+
+        /// <summary>
+        /// Test Harness
+        /// </summary>
+        /// <param name="args">the command line arguments</param>
+        public static void Main(String[] args)
+        {
+
+            // Test simple Load
+            XMLHelper oDOM = new XMLHelper();
+
+            // Test creating a DOM by handing and manipulating it
+            oDOM.createStandardRequest("test_type", "PYL38997", "CIMS");
+            oDOM.appendNode("test", "value");
+            System.Console.WriteLine("test:" + oDOM.getValue("test"));
+            System.Console.WriteLine("@type:" + oDOM.getValue("@type"));
+            oDOM.removeNode("test");
+            System.Console.WriteLine(oDOM.getRootXML());
+
+            // More manipulation
+            oDOM.appendNode("test", "value");
+            oDOM.setNode("test", "new Value");
+            oDOM = oDOM.appendNode("groups");
+            for (int i = 0; i < 10; i++)
+                oDOM.appendNode("group").appendAttribute("id", Convert.ToString(i));
+
+            // Test getNodes
+            XMLHelper[] oNodes = oDOM.getNodes("//group");
+            for (int i = 0; i < oNodes.Length; i++)
+                System.Console.WriteLine(oNodes[i].getXML());
+            System.Console.WriteLine(oDOM.getRootXML());
+
+            // Test appending an entirely new DOM
+            XMLHelper oNew = new XMLHelper("new");
+            oNew.appendNode("test", "40213423");
+            oDOM.appendNode(oNew);
+            System.Console.WriteLine(oDOM.getRootXML());
+
+            // Test appending a Nodelist
+            oNew.appendNode(oNodes);
+            System.Console.WriteLine(oNew.getRootXML());
+
+            System.Console.WriteLine(oDOM.getRootNode().getChildNodes().Length);
+            System.Console.WriteLine(oDOM.omNode.OwnerDocument.GetElementsByTagName("group").Count);
+            System.Console.WriteLine(oDOM.getParent().getNode("group").getXML());
+
+            XMLHelper o = new XMLHelper("response");
+            o.appendXPathNode("customer/@id", "1");
+            o.appendXPathNode("customer/name/first", "john");
+            o.appendXPathNode("customer/name/last", "doe");
+            o.appendNode("date", "01-jan-2005");
+            o.appendNode("empty_date", "");
+            System.Console.WriteLine(o.getDate("date"));
+            System.Console.WriteLine(o.getDate("empty_date"));
+            System.Console.WriteLine(o.getRootXML());
+            System.Console.WriteLine(o.omNode.ChildNodes.Count);
+            System.Console.WriteLine("Inner : " + o.getInnerXML());
+
+        }
+
+        #endregion
+
+        #region Distinct XML
+
+        /// <summary>
+        /// Appends a distinct set of the specified nodes to the current document.
+        /// See description for other appendDistinct overload (Example 1).
+        /// </summary>
+        public void appendDistinct(String sourceNodePath, String keyAttribute, String resultRoot)
+        {
+            appendDistinct(sourceNodePath, keyAttribute, resultRoot, null, "");
+        }
+
+        /// <summary>
+        /// High performance option for append distinct.
+        /// Allows direct access with an iterator.
+        /// Useful if adding multiple distincts from the same source rowset.
+        /// </summary>
+        /// <param name="incomingIterator"></param>
+        /// <param name="keyAttribute"></param>
+        /// <param name="resultRoot"></param>
+        /// <param name="additionalAttributes"></param>
+        /// <param name="resultNodesName"></param>
+        /// <param name="UseNodes">Forces the iterator to select nodes rather than attributes</param>
+        public void appendDistinct(XPathNodeIterator incomingIterator, String keyAttribute, String resultRoot, String[] additionalAttributes, String resultNodesName, Boolean UseNodes)
+        {
+            string value;
+            string attribute;
+            SortedList<string, object> ids = new SortedList<string, object>();
+            MemoryStream ms = new MemoryStream();
+
+            XmlTextWriter xmlWriter = new XmlTextWriter(ms, Encoding.UTF8);
+            xmlWriter.WriteStartElement(resultRoot);
+            XPathNodeIterator iterator = incomingIterator.Clone();
+            while (iterator.MoveNext())
+            {
+                if (UseNodes)
+                    attribute = keyAttribute;
+                else
+                    attribute = "@" + keyAttribute;
+                value = iterator.Current.SelectSingleNode(attribute).Value;
+                if (!ids.ContainsKey(value))
+                {
+                    if (additionalAttributes != null)
+                    {
+                        xmlWriter.WriteStartElement(resultNodesName);
+                        xmlWriter.WriteAttributeString(keyAttribute, value);
+                        ids.Add(value, null);
+                        foreach (String extraNode in additionalAttributes)
+                        {
+                            if (UseNodes)
+                                attribute = extraNode;
+                            else
+                                attribute = "@" + extraNode;
+                            xmlWriter.WriteAttributeString(extraNode, iterator.Current.SelectSingleNode(attribute).Value);
+                        }
+                        xmlWriter.WriteEndElement();
+                    }
+                    else
+                    {
+                        xmlWriter.WriteElementString(keyAttribute, value);
+                        ids.Add(value, null);
+                    }
+                }
+            }
+            xmlWriter.WriteEndElement();
+            xmlWriter.Flush();
+            ms.Seek(0, System.IO.SeekOrigin.Begin);
+
+            XmlDocument distinct = new XmlDocument();
+            distinct.Load(ms);
+            xmlWriter.Close();
+
+            omNode.AppendChild(omNode.OwnerDocument.ImportNode(distinct.DocumentElement, true));
+
+        }
+
+        public void appendDistinct(XPathNodeIterator incomingIterator, String keyAttribute, String resultRoot, String[] additionalAttributes, String resultNodesName)
+        {
+            appendDistinct(incomingIterator, keyAttribute, resultRoot, additionalAttributes, resultNodesName, false);
+        }
+
+        /// <summary>
+        /// Appends a distinct set of the specified nodes to the current document.
+        /// If additionalAttributes is null then resultNodesName is not used and the results will look
+        /// like the first example. With additionalAttributes 
+        /// </summary>
+        /// <param name="sourceNodePath">XPath to the nodes to be distincted.</param>
+        /// <param name="keyAttribute">Attribute to key on for determining uniqueness.</param>
+        /// <param name="resultRoot">Name of the root node to create and append the distinct nodes to.</param>
+        /// <param name="additionalAttributes">Additional attributes to include in the distinct items.</param>
+        /// <param name="resultNodesName">Name of individual result nodes.</param>
+        /// <param name="UseNodes">Use nodes instead of attributes for the data.</param>
+        /// 
+        /// <example >
+        /// 
+        /// Source:
+        /// <activities>
+        ///     <activity customer_id="1" name="Phil" type="M"/>
+        ///     <activity customer_id="1" name="Phil" type="C"/>
+        ///     <activity customer_id="2" name="Trev" type="M"/>
+        /// </activities>
+        /// 
+        /// Example 1: appendDistinct("activities/activity", "customer_id", "customer_ids")
+        /// <customer_ids execution_duration="0">
+        ///   <customer_id>1</customer_id> 
+        ///   <customer_id>2</customer_id> 
+        /// </customer_ids>
+        /// 
+        /// Example 2: appendDistinct("activities/activity", "customer_id", "customers", new string[] { "name" }, "customer" )
+        /// <customers execution_duration="0">
+        ///   <customer customer_id="1" name="Phil" /> 
+        ///   <customer customer_id="2" name="Trev" /> 
+        /// </customers>
+        /// 
+        /// </example>
+        public void appendDistinct(String sourceNodePath, String keyAttribute, String resultRoot, String[] additionalAttributes, String resultNodesName, Boolean UseNodes)
+        {
+            DateTime startTime = DateTime.Now;
+
+            XPathNavigator nav = omNode.CreateNavigator();
+            XPathExpression expression = nav.Compile(sourceNodePath);
+            XPathNodeIterator iterator = nav.Select(expression);
+
+            appendDistinct(iterator, keyAttribute, resultRoot, additionalAttributes, resultNodesName, UseNodes);
+
+            TimeSpan ExecutionDuration = DateTime.Now - startTime;
+
+            this.getNode(resultRoot).appendAttribute("execution_duration", ExecutionDuration.TotalMilliseconds.ToString());
+
+        }
+
+        public void appendDistinct(String sourceNodePath, String keyAttribute, String resultRoot, String[] additionalAttributes, String resultNodesName)
+        {
+            appendDistinct(sourceNodePath, keyAttribute, resultRoot, additionalAttributes, resultNodesName, false);
+        }
+
+        #endregion
+
+        #region Validation
+
+        public string validateXML(String schema)
+        {
+            StringReader srXml = new StringReader(getRootXML());
+            XmlValidatingReader vr;
+            XmlTextReader tr;
+            XmlSchemaCollection schemaCol = new XmlSchemaCollection();
+
+            XMLHelper oResponse = new XMLHelper("response");
+
+            try
+            {
+
+                schemaCol.Add(null, schema);
+                isValidXml = true;
+
+                // Read the xml.
+                tr = new XmlTextReader(srXml);
+
+                // Create the validator.
+                vr = new XmlValidatingReader(tr);
+
+                // Set the validation tyep.
+                vr.ValidationType = ValidationType.Auto;
+
+                // Add the schema.
+                if (schemaCol != null)
+                {
+                    vr.Schemas.Add(schemaCol);
+                }
+
+                // Set the validation event handler.
+                vr.ValidationEventHandler +=
+                   new ValidationEventHandler(ValidationCallBack);
+
+                // Read the xml schema.
+                while (isValidXml && vr.Read())
+                {
+                }
+
+                vr.Close();
+
+                oResponse.appendNode("valid", "true");
+
+                return oResponse.getRootXML();
+
+            }
+            catch (Exception ex)
+            {
+                oResponse.appendNode("valid", "false");
+                oResponse.appendNode("error", ex.Message);
+                ValidationError = ex.Message;
+                return oResponse.getRootXML();
+            }
+            finally
+            {
+                // Clean up...
+                vr = null;
+                tr = null;
+                schemaCol = null;
+            }
+        }
+
+        public Boolean validateUsing(String schema)
+        {
+            StringReader srXml = new StringReader(getRootXML());
+            XmlValidatingReader vr;
+            XmlTextReader tr;
+            XmlSchemaCollection schemaCol = new XmlSchemaCollection();
+            schemaCol.Add(null, schema);
+            isValidXml = true;
+
+            try
+            {
+                // Read the xml.
+                tr = new XmlTextReader(srXml);
+
+                // Create the validator.
+                vr = new XmlValidatingReader(tr);
+
+                // Set the validation tyep.
+                vr.ValidationType = ValidationType.Auto;
+
+                // Add the schema.
+                if (schemaCol != null)
+                {
+                    vr.Schemas.Add(schemaCol);
+                }
+
+                // Set the validation event handler.
+                vr.ValidationEventHandler +=
+                   new ValidationEventHandler(ValidationCallBack);
+
+                // Read the xml schema.
+                while (isValidXml && vr.Read())
+                {
+                }
+
+                vr.Close();
+
+                return isValidXml;
+            }
+            catch (Exception ex)
+            {
+                ValidationError = ex.Message;
+                return false;
+            }
+            finally
+            {
+                // Clean up...
+
+                vr = null;
+                tr = null;
+            }
+        }
+
+        private void ValidationCallBack(object sender,
+                                   ValidationEventArgs args)
+        {
+            // The xml does not match the schema.
+
+            isValidXml = false;
+            ValidationError = args.Message;
+        }
+
+        #endregion
+
+        #region XSL Transformation
+
+        /// <summary>
+        /// Transforms the current DOM using the XSL and returns an XMLHelper DOM
+        /// </summary>
+        /// <param name="zXSL">The XSL for the transform</param>
+        /// <returns>XMLHelper DOM with the result of the transform</returns>
+        public XMLHelper transform(String zXSL)
+        {
+            return transform(zXSL, new Dictionary<string, string>());
+        }
+
+        /// <summary>
+        /// Transforms the current DOM using the XSL to a TextWriter
+        /// </summary>
+        /// <param name="zXSL">The XSL for the transform</param>
+        /// <param name="oOut">Thre Textwriter to output to</param>
+        public void transform(String zXSL, TextWriter oOut)
+        {
+            transform(zXSL, new Dictionary<string, string>(), oOut);
+        }
+
+
+        public XMLHelper transform(Stream oXSL)
+        {
+            return transform(oXSL, new Dictionary<string, string>());
+        }
+        public XMLHelper transform(Stream oXSL, Dictionary<string, string> aParams)
+        {
+            StringWriter oText = new StringWriter();
+
+            transform(oXSL, aParams, oText);
+            return new XMLHelper(oText.GetStringBuilder());
+        }
+        /// <summary>
+        /// Transforms the current DOM using the XSL to a TextWriter
+        /// </summary>
+        /// <param name="zXSL">The XSL for the transform</param>
+        /// <param name="aParams">String Array of paramters to pass to the XSL</param>
+        /// <param name="oOut">Thre Textwriter to output to</param>
+        public void transform(String zXSL, Dictionary<string, string> aParams, TextWriter oOut)
+        {
+            Stream oXSL = new FileStream(zXSL, FileMode.Open);
+            transform(oXSL, aParams, oOut);
+        }
+        public void transform(Stream oXSL, Dictionary<string, string> aParams, TextWriter oOut)
+        {
+
+            XslCompiledTransform transformer = new XslCompiledTransform();
+
+            XsltArgumentList args = new XsltArgumentList();
+            foreach (string key in aParams.Keys)
+            {
+                args.AddParam(key, "", aParams[key]);
+            }
+
+            //Having to specify settings for the load, due to embedded script usage...
+            XsltSettings xsltSettings = new XsltSettings(true, true);
+            XmlUrlResolver xmlResolver = new XmlUrlResolver();
+            XmlReader reader = XmlReader.Create(oXSL);
+            transformer.Load(reader, xsltSettings, xmlResolver);
+            //transformer.Load(oXSL, );
+
+            if (omNode.ParentNode == omNode.OwnerDocument)
+                transformer.Transform(omNode.OwnerDocument, args, oOut);
+            else
+                transformer.Transform(omNode, args, oOut);
+
+        }
+
+
+        /// <summary>
+        /// Transforms the current DOM using the XSL and returns an XMLHelper DOM
+        /// </summary>
+        /// <param name="zXSL">The XSL for the transform</param>
+        /// <param name="aParams">String Array of paramters to pass to the XSL</param>
+        /// <returns>XMLHelper DOM with the result of the transform</returns>
+        public XMLHelper transform(String zXSL, Dictionary<string, string> aParams)
+        {
+            //try
+            //{
+            StringWriter oText = new StringWriter();
+
+            transform(zXSL, aParams, oText);
+            return new XMLHelper(oText.GetStringBuilder());
+            //}
+            //catch (Exception ex)
+            //{
+            //    System.Console.WriteLine(ex.Message);
+            //    return null;
+            //}
+        }
+
+
+        #endregion
+
+    }
+
+}