/*
 *  $Source: /cvsroot2/open/projects/WebARTS/ca/bc/webarts/servlet/DbXmlXsl.java,v $
 *  $Name:  $
 *  $Revision: 1.3 $
 *  $Date: 2005-04-10 11:53:16 -0700 (Sun, 10 Apr 2005) $
 *  $Locker:  $
 */
/*
 *  Copyright (C) 2001 WebARTS Design, North Vancouver Canada
 *  http://www.webarts.bc.ca
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package ca.bc.webarts.servlet;

import db2xml.util.DB2XMLException;
import db2xml.util.JDBCXMLProperties;
import db2xml.util.XMLOutput;

import db2xml.xml.JDBCXML;
import db2xml.xml.XMLDocument;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;

import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.UnknownHostException;
import java.net.URL;
import java.net.URLConnection;

import java.util.Calendar;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;

import javax.servlet.GenericServlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;

import org.w3c.dom.Document;

import org.xml.sax.SAXException;




/**
 * The class <code>DbXmlXsl</code> provides a server side engine for processing
 * a variety of XML/XSL tasks based on a SQL db query, or a saved XML file. <P>
 *
 * The XSL processing syntax assumes the Xalan package from
 * <a href="http://xml.apache.org">xml.apache.org</A>.<P>
 * All funtional options are accessible via the parameters passed to it.
 * <P>The db SQL to XML extraction is provided by the GNU
 * <A href="http://www-1.informatik.fh-wiesbaden.de/~turau/DB2XM">DB2XML library
 * </A> of  Java classes.
 *
 * This servlet has the following capabilities:
 * <OL>
 *   <LI> query a specified jdbc URL with a specified SQL statement and provide
 *   the result set in XML,
 *   <LI> transform the XMLResultSet using a specified XSL transform,
 *   <LI> save the XMLResultSet to a specified filename,
 *   <LI> transform XML (either from the above query, specified file, or parameter)
 *   with a XSL template
 *   <UL>
 *     <LI> XSL template specified by the caller
 *     <LI> to a html table representation of the data (default if a transformation
 *     is requested without a XSL file specified)
 *   </UL>
 *
 *   <LI> return the generated XML document with MIME type
 *     <code>text/xml</code></LI></OL>
 *   .

 *  <BR><BR><B>DbXmlXsl usage</B>:<BR>
 *   <pre>http://servername/DbXmlXsl?parameterList</PRE>where parameter list is
 *    a list of acceptable servlet parameter name value pairs separated
 *  by the &amp; character.<BR>This servlet will accept the following
 *  parameters:  <UL>
 *      <LI>dbQuery - the SQL to hit the db with
 *      <LI>saveXmlFile - true or false to save or not save the resultant xml
 *  from the dbQuery
 *      <LI>fileBaseDir - base dir for the xml save
 *      <LI>xslTransform - true or false to do or not do a transform
 *      <LI>xslURL - a URL to the xsl
 *      <LI>xmlURL - a URL to the xsl
 *      <LI>numXmlFiles - does mor than 1 transform at a time by taking the
 *  urls you give and appending a number to the end of them to get the
 *  sequence of urls
 *      <LI>xmlSource - directory based source for your xml on this server
 *      <LI>jdbcDriverClass - overrides the default to visit a different db
 *  with your dbQuery string
 *      <LI>jdbcURL - overrides the default to visit a different db
 *      <LI>jdbcUsername - overrides the default to visit a different db
 *      <LI>jdbcPassword - overrides the default to visit a different db
 *      <LI>dumpDebug - DOES not do the db Query or transform...
 *  just dumps the info it would have used
 *  </UL><BR>You can get this servlet to do a transform on its own
 *  (without a db query) by specifying the xslURL, xmlURL, and xslTransform.
 *  <BR>As Follows:
 *  <PRE>/DbXmlXsl?xslURL=http://yoururl&amp;xmlURL=http://yoururl&amp;xslTransform=true</PRE>
 *  <BR>Have Fun!<BR>
 *  Tom Gutwin P.Eng.
 *
 * @author    Tom Gutwin P.Eng
 */
public class DbXmlXsl extends HttpServlet
{

  /**
   * The Default XSL template to use (in the form of a URL)
   */
  String DEFAULT_XSL_STYLESHEET_URL = "http://warp2.webarts.bc.ca/xml/FancyXmlTreeViewer.xsl";
  /** A holder for this Servers System File Separator. **/
  private static final String SYSTEM_FILE_SEPERATOR = File.separator;
  /**
   * Description of the Field
   */
  private JDBCXML jx_ = null;
  /**
   * Description of the Field
   */
  private static JDBCXMLProperties map_ = null;
  private static String db2XmlPropFile_ = "db2xml.properties";
  /**
   * Description of the Field
   */
  private String xmlFileOutputName_ = "DbXmlXsl";
  /**
   * Description of the Field
   */
  private String xmlFileOutputDir_ = SYSTEM_FILE_SEPERATOR+"xml";
  /**
   * Description of the Field
   */
  private String fileBaseDir_ = SYSTEM_FILE_SEPERATOR;
  /**
   * The URL of this servlet
   */
  private String servletUrlStr_ = "/DbXmlXsl";

  private boolean dumpDebug_ = true;

  /**
   * This Servers Host Internet Address.
   **/
  private String myHost_ = null;
  /**
   * This Servers Host port.
   **/
  private String myPort_ = null;

  public String usageHtml_ = "<BR><BR><B>DbXmlXsl usage</B>:<BR>\n"+
    "<pre>http://servername/DbXmlXsl?parameterList</PRE>where parameter list is"+
    " a list of acceptable servlet parameter name value pairs separated " +
    "by the &amp; character.<BR>\nThis servlet will accept the following "+
    "parameters:\n  <UL>\n"+
    "    <LI>dbQuery - the SQL to hit the db with\n"+
    "    <LI>saveXmlFile - true or false to save or not save the resultant xml "+
    "from the dbQuery\n"+
    "    <LI>fileBaseDir - base dir for the xml save\n"+
    "    <LI>xslTransform - true or false to do or not do a transform\n"+
    "    <LI>xslURL - a URL to the xsl\n"+
    "    <LI>xmlURL - a URL to the xsl\n"+
    "    <LI>numXmlFiles - does mor than 1 transform at a time by taking the "+
    "urls you give and appending a number to the end of them to get the "+
    "sequence of urls\n"+
    "    <LI>xmlSource - directory based source for your xml on this server\n"+
    "    <LI>jdbcDriverClass - overrides the default to visit a different db "+
    "with your dbQuery string\n"+
    "    <LI>jdbcURL - overrides the default to visit a different db\n"+
    "    <LI>jdbcUsername - overrides the default to visit a different db\n"+
    "    <LI>jdbcPassword - overrides the default to visit a different db\n"+
    "    <LI>dumpDebug - DOES not do the db Query or transform... "+
    "just dumps the info it would have used\n"+
    "</UL><BR>\nYou can get this servlet to do a transform on its own "+
    "(without a db query) by specifying the xslURL, xmlURL, and xslTransform."+
    "<BR>\nAs Follows:<PRE>/DbXmlXsl?xslURL=http://yoururl&amp;xmlURL"+
    "=http://yoururl&amp;xslTransform=true</PRE><BR>\nHave Fun!<BR>"+
    "Tom Gutwin P.Eng.";


  /**
   * Creates a timestamp for the current time in the form of 'hour + "-" + min +
   * "-" + sec + "-" + millis'.
   *
   * @return   The CurrentTimeStamp value.
   */
  public static String createCurrentTimeStamp()
  {
    String value = "";
    Calendar calendar_ = Calendar.getInstance();
    int currMillis = calendar_.get(calendar_.MILLISECOND);
    String millis = String.valueOf(currMillis);
    if (currMillis < 10)
    {
      millis = "00" + currMillis;
    }
    else if (currMillis < 100)
    {
      millis = "0" + currMillis;
    }
    int currSec = calendar_.get(calendar_.SECOND);
    String sec = String.valueOf(currSec);
    if (currSec < 10)
    {
      sec = "0" + currSec;
    }
    int currMin = calendar_.get(calendar_.MINUTE);
    String min = String.valueOf(currMin);
    if (currMin < 10)
    {
      min = "0" + currMin;
    }
    int currHr = calendar_.get(calendar_.HOUR_OF_DAY);
    String hour = String.valueOf(currHr);
    if (currHr < 10)
    {
      hour = "0" + currHr;
    }

    return (String) hour + "-" + min + "-" + sec + "-" + millis;
  }


  /**
   * Initializes the servlet and loads some db2xml init data. The init method is
   * called once, automatically, by the network service each time it loads the
   * servlet. It is guaranteed to finish before any service requests are accepted.
   * <br>
   * The JDBCXML properties are read from a file named <code>db2xml.properties</code>
   * if an Servlet Init Parm - 'db2XmlPropFile' was not specified. This default
   * file must be placed in a server config directory or other suitable directory.
   *
   * @param config                servlet configuration information
   * @exception ServletException  if an error occured during initialization
   */
  public void init(ServletConfig config) throws ServletException
  {
    super.init(config); // invoked on GenericServlet and saves a reference of
    // the config for later use
    String initProp = getInitParameter("db2XmlPropFile");
    String fileOutputDir = getInitParameter("fileOutputDir");
    String fileBaseDir = getInitParameter("fileBaseDir");
    myPort_ = getInitParameter("hostPort");
    try
    {
      myHost_ = InetAddress.getLocalHost().getHostAddress();
      System.out.println("DbXmlXsl Servlet init(): myHost: "+myHost_);
      System.out.println("DbXmlXsl Servlet init(): myPort: "+myPort_);
      if (db2XmlPropFile_ != null && !db2XmlPropFile_.equals(""))
      {
        System.out.println("DbXmlXsl Servlet init(): Reading db2xml "+
        "properties file from " + initProp);
        db2XmlPropFile_ = initProp;
        map_ = new JDBCXMLProperties(db2XmlPropFile_);
      }
      else
      {
        // read from the default location
        map_ = new JDBCXMLProperties();
      }

      if (fileBaseDir != null && !fileBaseDir.equals(""))
      {
        System.out.println("DbXmlXsl Servlet init(): File Base Dir:  "+
        "" + fileBaseDir);
        fileBaseDir_ = fileBaseDir;
        if (!fileBaseDir_.endsWith(SYSTEM_FILE_SEPERATOR))
          fileBaseDir_ += SYSTEM_FILE_SEPERATOR;
      }

      if (fileOutputDir != null && !fileOutputDir.equals(""))
      {
        System.out.println("DbXmlXsl Servlet init(): File Output:  "+
        "" + fileOutputDir);
        xmlFileOutputDir_ = fileOutputDir;
      }

      servletUrlStr_ =  getServletName();
    }
    catch (DB2XMLException e)
    {
      throw new ServletException("2: " + e.getMessage());
    }
        catch (UnknownHostException e2)
    {
      throw new ServletException("2: " + e2.getMessage());
    }

  }


  /**
   * A method to generate an XML Document based on the result set from an SQL query
   * on a db. All db parameters are passed in the method parameters.
   *
   * @param jdbcDriverClass   the DriverClass name to override the defaults
   * @param jdbcUrl           the URL name to override the defaults
   * @param jdbcUser          the User name to override the defaults
   * @param jdbcUserPassword  the Password to override the defaults
   * @param sqlStatement      the SQL to execute
   *
   * @return                  The result query as an XML doc
   */
  public static XMLDocument db2XmlDocument(String jdbcDriverClass,
    String jdbcUrl,
    String jdbcUser,
    String jdbcUserPassword,
    String sqlStatement) throws DB2XMLException
  {
    XMLDocument retVal = null;
    JDBCXMLProperties map = null;
    if (map_ != null)
      map = map_;
    else
      map = new JDBCXMLProperties(); // uses the defaults

    if (jdbcDriverClass != null && !jdbcDriverClass.equals("") &&
      jdbcUrl != null && !jdbcUrl.equals("") &&
      jdbcUser != null &&
      jdbcUserPassword != null &&
      sqlStatement != null)
    {
      map.setProperty("driverClass", jdbcDriverClass);
      map.setProperty("dbUrl", jdbcUrl);
      map.setProperty("user", jdbcUser);
      map.setProperty("password", jdbcUserPassword);
      map.setProperty("dbQuery", sqlStatement);

      JDBCXML jx = new JDBCXML(map);
      try
      {
        jx.generateXML();
        retVal = jx.getXMLDocument();
      }
      catch (Exception ex)
      {
      }
      if (jx != null)
      {
        jx.closeDatabase();
      }
    }
    return retVal;
  }


  /**
   * A method to generate an XML Document based on the result set from an
   * SQL query on a the default db and username. All db parameters are
   * retrieved the from db2XmlPropFile_ field.
   *
   * @param sqlStatement      the SQL to execute
   *
   * @return                  The result query as an XML doc
   */
  public static XMLDocument db2XmlDocument(String sqlStatement)
                     throws DB2XMLException
  {
    JDBCXMLProperties map = null;
    if (map_ != null)
      map = map_;
    else if (db2XmlPropFile_ != null && !db2XmlPropFile_.equals(""))
      map = new JDBCXMLProperties(db2XmlPropFile_);
    else
      map = new JDBCXMLProperties();

    return db2XmlDocument(sqlStatement, map);
  }


  /**
   * A method to generate an XML Document based on the result set from an
   * SQL query on a the default db and username. All db parameters are
   * retrieved the passed map parameter.
   *
   * @param sqlStatement      the SQL to execute
   * @param map               The properties map to use for this query.
   *
   * @return                  The result query as an XML doc
   */
  public static XMLDocument db2XmlDocument(String sqlStatement,
                                           JDBCXMLProperties map)
                     throws DB2XMLException
  {
    XMLDocument retVal = null;
    if (sqlStatement != null)
    {
      map.setProperty("dbQuery", sqlStatement);

      JDBCXML jx = new JDBCXML(map);
      try
      {
        jx.generateXML();
        retVal = jx.getXMLDocument();
      }
      catch (Exception ex)
      {
      }
      if (jx != null)
      {
        jx.closeDatabase();
      }
    }
    return retVal;
  }


  /**
   * Writes the passed in XMLDocument to the specified XML file.
   *
   * @param xmlFilename  the resultant XMLfilename
   * @param xmlDoc       The XML Documewnt to write out
   *
   * @see #db2XmlDocument(String)
   */
  public static void writeXmlFile(String xmlFilename, XMLDocument xmlDoc)
              throws IOException, DB2XMLException
  {
    JDBCXMLProperties map = null;
    if (map_ != null)
      map = map_;
    else if (db2XmlPropFile_ != null && !db2XmlPropFile_.equals(""))
      map = new JDBCXMLProperties(db2XmlPropFile_);
    else
      map = new JDBCXMLProperties();
    writeXmlFile(xmlFilename, xmlDoc, map);
  }


  /**
   * Writes the passed in XMLDocument to the specified XML file.
   *
   * @param xmlFilename  the resultant XMLfilename
   * @param xmlDoc       The XML Documewnt to write out
   * @param map          The properties map to use for th DB2XML usage.
   */
  public static void writeXmlFile(String xmlFilename,
                                  XMLDocument xmlDoc,
                                  JDBCXMLProperties map)
              throws IOException, DB2XMLException
  {
    XMLOutput xmlOut = null;
    PrintWriter fileOut = new PrintWriter(new FileWriter(xmlFilename));
    xmlOut = new XMLOutput(map, fileOut, xmlDoc);
    xmlOut.writeToOutput();
  }


  /**
   * Performs the XSL transform on the XML.
   *
   * @param xmlUrl     The URL for the XML data
   * @param xslUrl     The URL for the XSL data
   * @param outWriter  The output writer to dump the output from the transform
   * @param params other parameters to pass directly to the transform
   */
  public static void doTransform(URL xmlUrl,
                                 URL xslUrl,
                                 PrintWriter outWriter,
                                 Hashtable params)
              throws IOException,
                     TransformerConfigurationException,
                     TransformerException,
                     IOException,
                     ParserConfigurationException,
                     SAXException
  {
    if (xmlUrl != null && xslUrl != null && outWriter != null)
    {
      InputStream xmlStream = xmlUrl.openStream();
      InputStream xslStream = xslUrl.openStream();
      if (xmlStream != null && xslStream != null)
      {
        doTransform(xmlStream, xslStream, outWriter, params);
      }
    }
  }


  /**
   * Performs the XSL transform on the XML.
   *
   * @param xmlStream  The Stream of XML data
   * @param xslStream  The Stream of XSL data
   * @param outStream  The Stream to dump the output from the transform
   * @param params other parameters to pass directly to the transform
   */
  public static void doTransform(InputStream xmlStream,
                          InputStream xslStream,
                          OutputStream outStream,
                          Hashtable params)
              throws TransformerConfigurationException,
                     TransformerException,
                     IOException,
                     ParserConfigurationException,
                     SAXException
  {
    doTransform(xmlStream, xslStream, new PrintWriter(outStream), params);
  }


  /**
   * Performs the XSL transform on the XML.
   *
   * @param xmlStream  The Stream of XML data
   * @param xslStream  The Stream of XSL data
   * @param outWriter  The OutputPrinter to dump the output from the transform
   * @param params other parameters to pass directly to the transform
   */
  public static void doTransform(InputStream xmlStream,
                          InputStream xslStream,
                          PrintWriter outWriter,
                          Hashtable params)
              throws TransformerConfigurationException,
                     TransformerException,
                     IOException,
                     ParserConfigurationException,
                     SAXException
  {
    //System.setProperty("javax.xml.transform.TransformerFactory","bla.bla");

    TransformerFactory tFactory = TransformerFactory.newInstance();
    if(false && tFactory.getFeature(DOMSource.FEATURE))
    {
      System.out.println("Using A Dom Parser");
      //Instantiate a DocumentBuilderFactory.
      DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();

      // And setNamespaceAware, which is required when parsing xsl files
      dFactory.setNamespaceAware(true);

      //Use the DocumentBuilderFactory to create a DocumentBuilder.
      DocumentBuilder dBuilder = dFactory.newDocumentBuilder();

      //Use the DocumentBuilder to parse the XSL stylesheet.
      Document xslDoc = dBuilder.parse(xslStream);

      // Use the DOM Document to define a DOMSource object.
      DOMSource xslDomSource = new DOMSource(xslDoc);

      // Set the systemId: note this is actually a URL, not a local filename
      //xslDomSource.setSystemId(xmlFileOutputDir_);

      // Process the stylesheet DOMSource and generate a Transformer.
      Transformer transformer = tFactory.newTransformer(xslDomSource);

      //Use the DocumentBuilder to parse the XML input.
      Document xmlDoc = dBuilder.parse(xmlStream);

      // Use the DOM Document to define a DOMSource object.
      DOMSource xmlDomSource = new DOMSource(xmlDoc);

      // Set the base URI for the DOMSource so any relative URIs it contains can
      // be resolved.
      //xmlDomSource.setSystemId(xmlFileOutputDir_);

      String name = null;
      for (Enumeration myEnum = params.keys(); myEnum.hasMoreElements();)
      {
        name = (String)myEnum.nextElement();
        transformer.setParameter(name, (String)params.get(name));
      }

      transformer.transform(xmlDomSource, new StreamResult(outWriter));
    }
    else
    { // use the default SAX parser
      // Get the XML input document and the stylesheet.
      Source xslSource = new StreamSource(xslStream);
      // Generate the transformer.
      Transformer transformer = tFactory.newTransformer(xslSource);

      String name = null;
      for (Enumeration myEnum = params.keys(); myEnum.hasMoreElements();)
      {
        name = (String)myEnum.nextElement();
        transformer.setParameter(name, (String)params.get(name));
      }

      // StreamSource wants either a reader or an inputStream
      Source xmlSource = new StreamSource(xmlStream);
      // Perform the transformation, sending the output to the response.
      transformer.transform(xmlSource, new StreamResult(outWriter));
    }
  }


  /**
   * Handles Post Requests by simply calling the doGet Method.
   *
   * @param req                   HttpServletRequest that encapsulates the
   *                              request to the servlet
   * @param res                   HttpServletResponse that encapsulates the
   *                              response from the servlet
   * @exception ServletException  if the request could not be handled
   * @exception IOException       in case of an write error while handling
   *                              request
   */
  public void doPost(HttpServletRequest req, HttpServletResponse res)
     throws ServletException, IOException
  {
    doGet(req, res);
  }


  /**
   * Performs the HTTP GET operation. This is the universal entry point to this
   * servlets functions. <P>
   *
   * It provides many options for how things are processed:
   * <UL>
   *   <LI> db/sql --> XML file</LI>
   *   <LI> db/sql --> XML returned to http response outputstream</LI>
   *   <LI> db/sql --> XML --> XSL (specified by the caller)
   *   <UL>default transforms available
   *     <LI> XML --> html tree representation</LI>
   *     <LI> XML --> html table representation</LI>
   *     <LI> XML --> comma separated value listing</LI>
   *   </UL>
   *   </LI>
   *   <LI> XML file --> XSL</LI>
   *   <LI> XML data from a passed parameter --> XSL</LI>
   * </UL>
   * The XSL template can be specified:
   * <UL>
   *   <LI> As a URL to a XSL file</LI> or as
   *   <LI> XSL data from a passed parameter</LI>
   * </UL>
   * The parameters used/passed that control the operation are:
   * <UL>
   *   <LI> dbQuery (valid sql query) default = ""</LI>
   *   <LI> xslTransform (true/false) default = "true"</LI>
   *   <LI> xslURL (a valid URL to an xsl file) default = "file://./defaultHtmlTable.xsl"
   *   </LI>
   *   <LI> saveXmlFile (true/false) default = "false"</LI>
   *   <LI> xmlURL (a valid URL to an xml file) default = ""</LI>
   *   <LI> xmlSource (valid xml) default = ""</LI>
   *   <LI>
   *   <OL>The following jdbc parametyers can be spec'd to override the defaults
   *     set in the db2xml.properties file.
   *     <LI> jdbcDriverClass (a driver package.classname) default = ""</LI>
   *     <LI> jdbcURL (the url of the db to query) default = ""</LI>
   *     <LI> jdbcUsername (the username to connect with) default = ""</LI>
   *     <LI> jdbcPassword (the password to connect with) default = ""</LI>
   *   </OL>
   *   </LI>
   *   <LI> </LI>
   *   <LI> </LI>
   *   <LI> </LI>
   * </UL>
   *
   *
   * @param req                   HttpServletRequest that encapsulates the
   *                              request to the servlet.
   * @param res                   HttpServletResponse that encapsulates the
   *                              response from the servlet.
   * @exception ServletException  if the request could not be handled.
   * @exception IOException       in case of an write error while handling
   *                              request.
   */
  public void doGet(HttpServletRequest req, HttpServletResponse res)
     throws IOException, ServletException
  {
    Hashtable otherParams = new Hashtable();

    // define a simple Vector of all acceptable parms so we can use the
    // '.contains' method to quickly check if a param is expected
    Vector definedParamKeys = new Vector();
    definedParamKeys.add("dbQuery");
    definedParamKeys.add("xslTransform");
    definedParamKeys.add("saveXmlFile");
    definedParamKeys.add("xslURL");
    definedParamKeys.add("xmlURL");
    definedParamKeys.add("numXmlFiles");
    definedParamKeys.add("xmlSource");
    definedParamKeys.add("jdbcDriverClass");
    definedParamKeys.add("jdbcURL");
    definedParamKeys.add("jdbcUsername");
    definedParamKeys.add("jdbcPassword");
    definedParamKeys.add("dumpDebug");
    definedParamKeys.add("fileBaseDir");

    //These properties should be set in a servlet environment
    //regardless of the values defined in the property file
    map_.setProperty("out", "stream");
    map_.setProperty("el.binfields", "ignore");
    map_.setBooleanProperty("el.protectStrings", true);
    map_.setProperty("genDTD", "no");

    // get the input parameters
    String dbQuery = req.getParameter("dbQuery");
    String xslTransformStr = req.getParameter("xslTransform");
    String xslURL = req.getParameter("xslURL");
    String saveXmlFileStr = req.getParameter("saveXmlFile");
    String xmlURL = req.getParameter("xmlURL");
    String numXmlFilesStr = req.getParameter("numXmlFiles");
    String xmlSource = req.getParameter("xmlSource");
    String jdbcDriverClass = req.getParameter("jdbcDriverClass");
    String jdbcURL = req.getParameter("jdbcURL");
    String jdbcUsername = req.getParameter("jdbcUsername");
    String jdbcPassword = req.getParameter("jdbcPassword");
    String dumpDebugStr = req.getParameter("dumpDebug");
    String fileBaseDir = req.getParameter("fileBaseDir");

    // now get any other params that were passed, so we can forward them to the
    // transformer
    Enumeration myEnum = req.getParameterNames();
    String name = null;
    while (myEnum.hasMoreElements())
    {
      name = (String) myEnum.nextElement();
      if (!definedParamKeys.contains(name))
        otherParams.put(name, req.getParameter(name));
    }

    String contentTypeStr = "text/html";
    boolean proceed = true;
    boolean useXmlSource = false;
    String errorMsg = "unknown";
    String xmlFileOutputName = xmlFileOutputName_;

    // cast parameters to appropriate types and validate at the same time
    boolean saveXmlFile =
      (saveXmlFileStr != null ? saveXmlFileStr.equals("true") : false);
    boolean doXslTransform =
      (xslTransformStr != null ? xslTransformStr.equals("true") : true);
    dumpDebug_ =
      (dumpDebugStr != null ? dumpDebugStr.equals("true") : false);
    int numXmlFiles = 1;
    if (numXmlFilesStr != null && !numXmlFilesStr.equals(""))
    {
      numXmlFiles = Integer.parseInt(numXmlFilesStr);
    }

    //Parameter validation
    boolean doDbQuery = (dbQuery != null ? !dbQuery.equals("") : false);
    boolean streamXmlOut =
      (doDbQuery && !saveXmlFile && !doXslTransform ? true : false);

    // confirm BaseDir info
    if (fileBaseDir != null && !fileBaseDir.equals(""))
    {
      fileBaseDir_ = fileBaseDir;
      if (!fileBaseDir_.endsWith(SYSTEM_FILE_SEPERATOR))
        fileBaseDir_ += SYSTEM_FILE_SEPERATOR;
    }

    // confirm xsl info
    if (xslURL == null || xslURL.equals(""))
    {
      xslURL = DEFAULT_XSL_STYLESHEET_URL;
    }

    // confirm xml data source
    if (!doDbQuery)
    {
      dbQuery = "";
      if (saveXmlFile)
      {
        proceed = false;
        errorMsg = "Request to Save the XML to file BUT " +
                   "no dbQuery parameter was specified."+usageHtml_;
      }
      else
      {
        // we better make sure there is valid XML coming from somewhere else
        if ((xmlURL == null || xmlURL.equals("")))
        {
          if (xmlSource == null || xmlSource.equals(""))
          {
            // no XML found
            proceed = false;
            errorMsg = "At least one source for the XML must be specified: " +
                       "dbQuery, xmlURL or xmlSource."+usageHtml_;
          }
          else
          {
            useXmlSource = true;
          }
        }
        else  //valid xmlURL
        {
          // do nothing here ... save the actual processing for later
        }
      }
    }
    else // we are doing a dbQuery
    {
      if (!streamXmlOut)
      {
        if(!doXslTransform)
        {
          // we have been asked to send the output to a file so validate the
          // filename
          if(xmlURL == null || xmlURL.equals(""))
          {
            // XML output filename not spec'd so bug out
            proceed = false;
            errorMsg = "Request to Save the XML to file BUT " +
                       "no xmlURL parameter was specified."+usageHtml_;
          }
        }
      }
      else
      {
        contentTypeStr = "text/xml";
      }
    }
    // by now we have
    // the proceed flag init and
    // a valid Xml data Source and
    // an xsl data source URL set up and
    // the returned contentType is set

    // lets do the work for the request
    PrintWriter out = res.getWriter();
    String absoluteFilename = "";

    if (proceed)
    {
      res.setStatus(HttpServletResponse.SC_OK);
      XMLDocument xmlDoc = null;
      try
      {
        if (doDbQuery)
        {
          // query the db and return the XML
          xmlDoc = db2XmlDocument(dbQuery);
          if (saveXmlFile)
          {
            absoluteFilename = xmlFileOutputDir_ + this.SYSTEM_FILE_SEPERATOR +
              convertSystemDependantPath(parseIntoUrl(xmlURL));
            writeXmlFile(absoluteFilename, xmlDoc);
            xmlURL = "file:///"+ absoluteFilename;
          }
          else
          {
            // we need to Pump the XMLOutput from the xmlDoc into an InputStream
            // for now just dump into a temp file that we can read from.
            String tmp = System.getProperty("java.io.tmpdir");
            if (tmp == null || tmp.equals(""))
              tmp = "." + SYSTEM_FILE_SEPERATOR;
            else
            {
              if (!(tmp.trim().endsWith(SYSTEM_FILE_SEPERATOR)))
              {
                tmp = tmp.trim() + SYSTEM_FILE_SEPERATOR;
              }
            }
            absoluteFilename = tmp + xmlFileOutputName_ + "TempStream.xml";
            writeXmlFile(absoluteFilename, xmlDoc);
            xmlURL = "file:///"+ absoluteFilename;
          }

        }
        else // no db query specified
        {
          absoluteFilename = parseIntoUrl(xmlURL).toString();
          // we only have to do something if we are going to Stream
          if (streamXmlOut)
          {
            // not implemented yet
            xmlDoc = new XMLDocument(map_);
            // the xmlDoc will now have to be filled with the data from
            // either the xmlSource or xmlURL
          }
        }

        /* Now the XML is is place.. so send something back to the requester */
        /* ***************************************************************** */
        if (dumpDebug_)
        {
          res.setContentType("text/html");
          out.write("<HTML>\n");
          out.write("<Head>\n");
          out.write("<title>" + getServletName() +
                    " - Debug Output</TITLE></head>\n");
          out.write("<body>\n<h2>" + getServletName() +
                    " - Debug Output</h2>\n");
          out.write("<H4>Request was:" + "</H4>" + req.getQueryString() +
                    "<H4>Request Parms are:</H4><OL>");
          String parm;
          String val;
          for (Enumeration parmEnum = req.getParameterNames();
               parmEnum.hasMoreElements(); )
          {
            parm = (String) parmEnum.nextElement();
            val = req.getParameter(parm);
            out.write("<LI>"+parm + " : " + val + "</LI>");
          }
          out.write("</OL>\n<B>Other Settings</B><BR>\n");
          out.write((saveXmlFile?"Saved ":"UnSaved ")+"XML File=" +
                     absoluteFilename + "<BR>\n");
          out.write("doXslTransform = " +doXslTransform + "<BR>\n");
          out.write("users current dir = " +System.getProperty("user.dir") +
            "<BR>\n");
          out.write("XML URL = " + parseIntoUrl(xmlURL) + "<BR>\n");
          out.write("XSL URL = " +parseIntoUrl(xslURL) + "<BR>\n");
          for (Enumeration parmEnum = otherParams.keys();
               parmEnum.hasMoreElements(); )
          {
            parm = (String) parmEnum.nextElement();
            val = (String)otherParams.get(parm);
            out.write(" - "+parm + " : " + val + "<BR>\n");
          }
          out.write(" " +
                    "\n");
          out.write("</body>\n</html>");
        }
        else  // now send something back to the Client
        {
          res.setContentType("text/html");
          if (doXslTransform)
          {
            InputStream xmlStream = null;
            InputStream xslStream = null;
            if (numXmlFiles == 1)
            {
              URL in = parseIntoUrl(xmlURL);
              URL trans = parseIntoUrl(xslURL);

              if (!in.getProtocol().equals("file"))
              {

                URLConnection inConnection = in.openConnection();
                URLConnection transConnection = trans.openConnection();

                // test for access
                try
                {
                  xmlStream = inConnection.getInputStream();
                  xslStream = transConnection.getInputStream();
                }
                catch (IOException ex)
                {
                  try
                  {
                    xmlStream = in.openStream();
                    xslStream = trans.openStream();
                  }
                  catch (Exception ex2)
                  {
                    errorMsg = ex2.getMessage() +
                      "<BR>Unable to complete the transformation because I "+
                      "cannot read one of the required files:<BR>" +
                      "Please check the xmlURL and the xslURL.<BR>"+
                      "xml=" + in.toExternalForm() +
                      "<BR>xsl=" + trans.toExternalForm()+usageHtml_ ;
                    proceed = false;
                  }
                }
              }
              else
              { //get a file Input stream
                xmlStream = new FileInputStream(fileBaseDir_ + xmlURL);
                xslStream = new FileInputStream(fileBaseDir_ + xslURL);
              }

              if (xmlStream != null && xslStream != null && proceed)
                doTransform(xmlStream, xslStream, out, otherParams);
              else
              {
                if (proceed)
                {
                  errorMsg = "Unable to complete the transformation because " +
                    "I cannot read one of the required files:<BR>" +
                    "Please check the xmlURL and the xslURL."+usageHtml_;
                  proceed = false;
                }
              }
            }
            else
            {
              // build in the capability to process more than 1 xml/xsl in line
              // produce 1 output report based on a number of xml files
              for (int i=1; i <= numXmlFiles; i++)
              {
                //alter the URL names we are looking for
                xmlStream = parseIntoUrl(xmlURL+i+".xml").openStream();
                xslStream = parseIntoUrl(xslURL+i+".xsl").openStream();
                doTransform(xmlStream, xslStream, out, otherParams);
              }
            }
          }
          else if (streamXmlOut)
          {
            res.setContentType("text/xml");

            // send the XML straight back to the client
            // yet to implement
          }
          else
          {
            if (saveXmlFile)
            {
              res.setContentType("text/html");
              out.write("<HTML>\n");
              out.write("<Head>\n");
              out.write("<title>" + getServletName() +
                        " - Completed</TITLE></head>\n");
              out.write("<body>\n<h2>" + getServletName() +
                        " - Completed</h2>\n");
              out.write("<H4>File Saved Successfully:</H4>");
              out.write("XML File=" + absoluteFilename + "<BR>\n");
              out.write("XML URL = " + parseIntoUrl(xmlURL) + "<BR>\n");
              out.write("</body>\n</html>");

            }
            else // error ... an error response is provided below
            {
              errorMsg = "One of the following 3 output options was not " +
                "specified/completed:\n<OL><LI>XSL Transformation<LI>Stream " +
                "the XML Results back without transformation<LI>Save the XML " +
                "to a file.</OL>"+usageHtml_;
              proceed = false;
            }
          }
        }
      }
      catch (Exception e)
      {
          out.write("<H3>DbXmlXsl threw an exception on the server:</H3>" +
          "<H4>query was:</H4>" + dbQuery +
          "<H4>Request was:" + "</H4>" + req.getQueryString() +
          "<H4>Request Parms are:</H4>");

        String parm;
        String val;
        for (Enumeration parmEnum = req.getParameterNames();
             parmEnum.hasMoreElements(); )
        {
          parm = (String) parmEnum.nextElement();
          val = req.getParameter(parm);
          out.write(parm + " : " + val + "<BR>");
        }
          out.write("</OL>\n<B>Other Settings</B><BR>\n");
          out.write((saveXmlFile?"Saved ":"UnSaved ")+"XML File=" +
                     absoluteFilename + "<BR>\n");
          out.write("doXslTransform = " +doXslTransform + "<BR>\n");
          out.write("users current dir = " +System.getProperty("user.dir") +
            "<BR>\n");
          out.write("XML URL = " + parseIntoUrl(xmlURL) + "<BR>\n");
          out.write("XSL URL = " +parseIntoUrl(xslURL) + "<BR>\n");
          for (Enumeration parmEnum = otherParams.keys();
               parmEnum.hasMoreElements(); )
          {
            parm = (String) parmEnum.nextElement();
            val = (String)otherParams.get(parm);
            out.write(" - "+parm + " : " + val + "<BR>\n");
          }
          out.write(" " +
                    "\n");
        out.write("<H4>error message:</H4>" + e.getMessage() + "<BR><PRE>");
        e.printStackTrace(out);
        out.write("</PRE><HR>"+usageHtml_+"</body></html>");
      }
    }

    if (!proceed)
    {
      res.setStatus(HttpServletResponse.SC_BAD_REQUEST);
      res.setContentType("text/html");
      out.write("<HTML>\n");
      out.write("<Head>\n");
      out.write("<title>" + getServletName() +
                " - Request Not Completed</TITLE></head>\n");
      out.write("<body>\n<h2>" + getServletName() +
                " - Request Not Completed</h2>\n");
      out.write("<H4>Request was:" + "</H4>" + req.getQueryString() +
                "<H4>Request Parms are:</H4>");
      String parm;
      String val;
      for (Enumeration parmEnum = req.getParameterNames();
           parmEnum.hasMoreElements(); )
      {
        parm = (String) parmEnum.nextElement();
        val = req.getParameter(parm);
        out.write(parm + " : " + val + "<BR>");
      }
      out.write("<HR>\n");
      out.write("<P>Possible error: " + errorMsg + "\n");
      out.write("<P>Please review/correct the request parameters " +
                "and resubmit.\n");
      out.write("</body>\n</html>");
    }
    out.flush();

  }


  /**
   * Parses a String representation of a URL or absolute file path and converts
   * it into a URL.<P>This method is a bit forgiving... if the string is not
   * a correctlty formatted http, ftp, or file URL it will assume it is a file
   * URL and create the returned URL as such.
   *
   * @param value is the String to convert into a URL.
   *
   * @return the Valid URL for the Executable or null if this method failed to
   *         convert the passed in string.
   *
   * @throws MalformedURLException if the passed in String is not a URL
   **/
  private URL parseIntoUrl(String value)
     throws MalformedURLException
  {
    URL retVal = null;
    if (value != null)
    {
      if (value.toLowerCase().startsWith("http:/") ||
          value.toLowerCase().startsWith("ftp:/")  ||
          value.toLowerCase().startsWith("file:/"))
      {
        // the following throws a MalformedURLException if value is bad
        retVal = new URL(value);
      }
      else // assume it is a http:// path
      {
        try
        {
          String tempPath = value; // Assume Un*x ... no replacement needed
          if (SYSTEM_FILE_SEPERATOR.equals("\\"))
          {
            /* Replace the file separators with the forward slash */
            tempPath = ""; // start from scratch
            for ( int i = 0; i < value.length(); i++)
            {
              if (value.charAt(i) != SYSTEM_FILE_SEPERATOR.charAt(0) )
              {
                tempPath += value.substring(i,i+1);
              }
              else
              {
                tempPath += "/";
              }
            }
          }
          retVal = new URL("file://" + fileBaseDir_ + tempPath);
        }
        catch (NullPointerException badUrl)
        {
          throw new MalformedURLException("Can't parse the location URL from the " +
            "file path provided.");
        }
      }
    }
    return retVal;
  }


  /**
   * Converts the path component of a URL to the native relative file path.
   *
   * @param the url to use to convert.
   *
   * @return the converted path string. It will return a "" if the URL does not
   *         include a filepath portion.
   **/
  public String convertSystemDependantPath(URL url)
  {
    String retVal = "";

    // First check if we need to do the '/' conversion
    if (url != null && SYSTEM_FILE_SEPERATOR.equals("\\"))
    {
      // yup... we have to switch 'em
      // gotta use getFile instead of getPath which is a jdk 1.3 method
      String tempPath = url.getFile();
      for ( int i = 0; i < tempPath.length();i++)
      {
        if (tempPath.charAt(i) != '/' )
        {
          retVal += tempPath.substring(i,i+1);
        }
        else
        {
          if (i != 0)
            retVal += "\\";
        }
      }
    }
    else if (url != null)
      // It is a Un*x path (no conversion needed)
      retVal = url.getFile().substring(1);

    return retVal;
  }
}