Metacat

/**

 *  '$RCSfile$'

 *    Purpose: A Class that transforms an XML text document

 *             into a another type using XSL

 *  Copyright: 2000 Regents of the University of California and the

 *             National Center for Ecological Analysis and Synthesis

 *    Authors: Matt Jones

 *

 * '$Author: tao $'

 * '$Date: 2008-06-18 16:30:39 -0700 (Wed, 18 Jun 2008) $'

 * '$Revision: 4010 $'

 *

 * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 */

package edu.ucsb.nceas.metacat;

import java.io.*;

import java.net.URL;

import java.net.MalformedURLException;

import java.sql.*;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Stack;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.Transformer;

import javax.xml.transform.stream.StreamSource;

import javax.xml.transform.stream.StreamResult;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerConfigurationException;

import org.apache.log4j.Logger;

import org.apache.xerces.parsers.DOMParser;

import org.w3c.dom.Attr;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.NodeList;

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.w3c.dom.DocumentType;

import org.xml.sax.SAXException;

import org.xml.sax.InputSource;

import org.apache.xerces.dom.DocumentTypeImpl;

import org.apache.xpath.XPathAPI;

import org.w3c.dom.NamedNodeMap;

/*

import oracle.xml.parser.v2.XSLStylesheet;

import oracle.xml.parser.v2.XSLException;

import oracle.xml.parser.v2.XMLParseException;

import oracle.xml.parser.v2.XSLProcessor;

import oracle.xml.parser.v2.XMLDocument;

import oracle.xml.parser.v2.DOMParser;

*/

import org.w3c.dom.Document;

import org.w3c.dom.Node;

import org.w3c.dom.Element;

import org.xml.sax.SAXException;

import java.util.Properties;

/**

 * A Class that transforms XML documents utitlizing XSL style sheets

 */

public class DBTransform {

  //private Connection	conn = null;

  private MetaCatUtil   util = null;

  private String 	configDir = null;

  private String	defaultStyle = null;

  private Logger logMetacat = Logger.getLogger(DBTransform.class);

  private String httpServer = null;

  private String contextURL = null;

  private String servletURL = null;

  /**

   * construct a DBTransform instance.

   *

   * Generally, one calls transformXMLDocument() after constructing the instance

   *

   * @param conn the database connection from which to lookup the public ids

   */

  public DBTransform()

                  throws IOException,

                         SQLException,

                         ClassNotFoundException

  {

    //this.conn = conn;

    util = new MetaCatUtil();

    configDir = util.getOption("config-dir");

    defaultStyle = util.getOption("default-style");

    httpServer = util.getOption("httpserver");

    contextURL = util.getOption("httpserver")+"/"+util.getOption("context");

    servletURL = util.getOption("httpserver")+util.getOption("servletpath");

  }

  /**

   * @see transformXMLDocument(String doc, String sourceType,

   *            String targetType, String qformat, PrintWriter pw,

   *            String sessionid)

   */

  public void transformXMLDocument(String doc, String sourceType,

                String targetType, String qformat, PrintWriter pw,

                Hashtable param)

  {

    transformXMLDocument(doc, sourceType, targetType, qformat, pw, param, null);

  }

   /**

   * @see transformXMLDocument(String doc, String sourceType,

   *            String targetType, String qFormat, StringWriter pw

   *            String sessionid)

   */

  public void transformXMLDocument(String doc, String sourceType,

                String targetType, String qFormat, StringWriter pw)

  {

    transformXMLDocument(doc, sourceType, targetType, qFormat, pw, null);

  }

  /**

   * Transform an XML document using the stylesheet reference from the db

   *

   * @param doc the document to be transformed

   * @param sourcetype the document type of the source

   * @param targettype the target document type

   * @param qformat the name of the style set to use

   * @param pw the PrintWriter to which output is printed

   * @param params some parameters for eml2 transformation

   */

  public void transformXMLDocument(String doc, String sourceType,

                                   String targetType, String qformat,

                                   PrintWriter pw, Hashtable param,

                                   String sessionid)

 {

    // Look up the stylesheet for this type combination

    String xslSystemId = getStyleSystemId(qformat, sourceType, targetType);

    if (xslSystemId != null)

    {

      try

      {// Create a stylesheet from the system id that was found

        doc = removeDOCTYPE(doc);

        StringReader xml = new StringReader(doc);

        StreamResult result = new StreamResult(pw);

        doTransform(xml, result, xslSystemId, param, qformat, sessionid);

      }

      catch (Exception e)

      {

    	  logMetacat.error(xslSystemId + ": Error transforming document in " +

                   "DBTransform.transformXMLDocument: " +

                   e.getMessage());

      }

    }

    else

    {

      // No stylesheet registered form this document type, so just return the

      // XML stream we were passed

      pw.print(doc);

    }

  }

  /**

   * Transform an XML document to StringWriter using the stylesheet reference

   * from the db

   * @param doc the document to be transformed

   * @param sourceType the document type of the source

   * @param targetType the target document type

   * @param qFormat the name of the style set to use

   * @param pw the StringWriter to which output will be stored

   */

  public void transformXMLDocument(String doc, String sourceType,

                String targetType, String qFormat, StringWriter pw,

                String sessionid)

  {

    // Look up the stylesheet for this type combination

    String xslSystemId = getStyleSystemId(qFormat, sourceType, targetType);

    if (xslSystemId != null)

    {

      // Create a stylesheet from the system id that was found

      try

      {

        doc = removeDOCTYPE(doc);

        StringReader xml = new StringReader(doc);

        StreamResult result = new StreamResult(pw);

        doTransform(xml, result, xslSystemId, null, qFormat, sessionid);

      }

      catch (Exception e)

      {

        logMetacat.error(xslSystemId + ": Error transforming document in " +

                   "DBTransform.transformXMLDocument: " +

                   e.getMessage());

      }

    }

    else

    {

      // No stylesheet registered form this document type, so just return the

      // XML stream we were passed

      pw.write(doc);

    }

  }

  /**

   * Method to do transform for a string reader

   * @param doc the document to be transformed

   * @param sourcetype the document type of the source

   * @param targettype the target document type

   * @param qformat the name of the style set to use

   * @param pw the PrintWriter to which output is printed

   * @param params some parameters for eml2 transformation

   */

   public void transformXMLDocument(StringReader docContent, String sourceType,

                                   String targetType, String qformat,

                                   PrintWriter pw, Hashtable param,

                                   String sessionid)

   {

     // Look up the stylesheet for this type combination

    String xslSystemId = getStyleSystemId(qformat, sourceType, targetType);

    if (xslSystemId != null)

    {

      try

      {// Create a stylesheet from the system id that was found

        StreamResult result = new StreamResult(pw);

        doTransform(docContent, result, xslSystemId, param, qformat, sessionid);

      }

      catch (Exception e)

      {

    	  logMetacat.error(xslSystemId + ": Error transforming document in " +

                   "DBTransform.transformXMLDocument: " +

                   e.getMessage());

      }

    }

    else

    {

      // No stylesheet registered form this document type, so just return the

      // XML stream we were passed

      pw.print(docContent);

    }

   }

  /**

   * Reads skin's config file if it exists, and populates Transformer paramaters

   * with its contents.

   * It then adds the parameters passed to it via Hashtable param to the Transformer.

   * It then calls the Transformer.transform method.

   */

  private void doTransform(StringReader docContent, 

          StreamResult resultOutput,

          String xslSystemId, 

          Hashtable param,

          String qformat, 

          String sessionid) 

          throws Exception {

      Properties skinOptions;

      TransformerFactory tFactory;

      Transformer transformer;

      String key, value;

      StreamSource xml;

      Enumeration en;

      Iterator iterIt;

      Map.Entry entry;

      if (xslSystemId != null) {

        tFactory = TransformerFactory.newInstance();

        transformer = tFactory.newTransformer(new StreamSource(xslSystemId));

        transformer.setParameter("qformat", qformat);

        logMetacat.warn("qformat: "+qformat);

        if (MetaCatUtil.hasSkinConfig(qformat)) {

            skinOptions = MetaCatUtil.getSkinConfig(qformat);

            iterIt = skinOptions.entrySet().iterator();

            while (iterIt.hasNext()) {

                entry = (Entry) iterIt.next();

                key = (String) entry.getKey();

                value = (String) entry.getValue();

                transformer.setParameter(key, value);

            }

        }

        if (sessionid != null && !sessionid.equals("null")) {

          transformer.setParameter("sessid", sessionid);

        }

        //set up the default params (can be overridden by the passed in params)

        String cgiPrefix = MetaCatUtil.getOption("cgi-prefix");

        logMetacat.debug("cgi-prefix=" + cgiPrefix);

        logMetacat.debug("httpServer=" + httpServer);

        logMetacat.debug("contextURL=" + contextURL);

        logMetacat.debug("serletPath=" + servletURL);

        transformer.setParameter("cgi-prefix", cgiPrefix);

        transformer.setParameter("httpServer", httpServer);

        transformer.setParameter("contextURL", contextURL);

        transformer.setParameter("servletURL", servletURL);

        // Set up parameter for transformation

        if ( param != null) {

          en = param.keys();

          while (en.hasMoreElements()) {

            key = (String) en.nextElement();

            value = ((String[]) (param.get(key)))[0];

            logMetacat.info(key+" : "+value);

            transformer.setParameter(key, value);

          }

        }

        xml = new StreamSource(docContent);

        transformer.transform(xml,resultOutput);

    }

  }//doTransform

  /**

   * gets the content of a tag in a given xml file with the given path

   * @param f the file to parse

   * @param path the path to get the content from

   */

  public static NodeList getPathContent(File f, String path)

  {

    if(f == null)

    {

      return null;

    }

    DOMParser parser = new DOMParser();

    InputSource in;

    FileInputStream fs;

    try

    {

      fs = new FileInputStream(f);

      in = new InputSource(fs);

    }

    catch(FileNotFoundException fnf)

    {

      fnf.printStackTrace();

      return null;

    }

    try

    {

      parser.parse(in);

      fs.close();

    }

    catch(Exception e1)

    {

      System.err.println("File: " + f.getPath() + " : parse threw: " +

                         e1.toString());

      return null;

    }

    Document doc = parser.getDocument();

    try

    {

      NodeList docNodeList = XPathAPI.selectNodeList(doc, path);

      return docNodeList;

    }

    catch(Exception se)

    {

      System.err.println("file: " + f.getPath() + " : parse threw: " +

                         se.toString());

      return null;

    }

  }

  /**

   * Lookup a stylesheet reference from the db catalog

   *

   * @param qformat    the named style-set format

   * @param sourcetype the document type of the source

   * @param targettype the document type of the target

   */

  public String getStyleSystemId(String qformat, String sourcetype,

                String targettype) {

    String systemId = null;

    if ((qformat == null) || (qformat.equals("html"))) {

      qformat = defaultStyle;

    }

    // Load the style-set map for this qformat into a DOM

    try {

      boolean breakflag = false;

      String filename = configDir + "/" + qformat + "/" + qformat + ".xml";

      logMetacat.warn("Trying style-set file: " + filename);

      File f = new File(filename);

      NodeList nlDoctype = getPathContent(f, "/style-set/doctype");

      NodeList nlDefault = getPathContent(f, "/style-set/default-style");

      Node nDefault = nlDefault.item(0);

      systemId = nDefault.getFirstChild().getNodeValue(); //set the default

      for(int i=0; i<nlDoctype.getLength(); i++)

      { //look for the right sourcetype

        Node nDoctype = nlDoctype.item(i);

        NamedNodeMap atts = nDoctype.getAttributes();

        Node nAtt = atts.getNamedItem("publicid");

        String doctype = nAtt.getFirstChild().getNodeValue();

        if(doctype.equals(sourcetype))

        { //found the right sourcetype now we need to get the target type

          NodeList nlChildren = nDoctype.getChildNodes();

          for(int j=0; j<nlChildren.getLength(); j++)

          {

            Node nChild = nlChildren.item(j);

            String childName = nChild.getNodeName();

            if(childName.equals("target"))

            {

              NamedNodeMap childAtts = nChild.getAttributes();

              Node nTargetPublicId = childAtts.getNamedItem("publicid");

              String target = nTargetPublicId.getFirstChild().getNodeValue();

              if(target.equals(targettype))

              { //we found the right target type

                NodeList nlTarget = nChild.getChildNodes();

                for(int k=0; k<nlTarget.getLength(); k++)

                {

                  Node nChildText = nlTarget.item(k);

                  if(nChildText.getNodeType() == Node.TEXT_NODE)

                  { //get the text from the target node

                    systemId = nChildText.getNodeValue();

                    breakflag = true;

                    break;

                  }

                }

              }

            }

            if(breakflag)

            {

              break;

            }

          }

        }

        if(breakflag)

        {

          break;

        }

      }

    }

    catch(Exception e)

    {

      System.out.println("Error parsing style-set file: " + e.getMessage());

      e.printStackTrace();

    }

    //Check if the systemId is relative path, add a postfix - the contextULR to systemID. 

    if (systemId != null && systemId.indexOf("http://" ) == -1)

    {

    	systemId = contextURL+systemId;

    }

    // Return the system ID for this particular source document type

    logMetacat.info("style system id is: "+systemId);

    return systemId;

  }

 /* Method to modified the system id of xml input -- make sure it

    points to system id in xml_catalog table

  */

  private void modifiedXmlStreamSource(StreamSource xml, String publicId)

                                       throws Exception

  {

    // make sure the xml is not null

    if (xml == null || publicId == null)

    {

      return;

    }

    logMetacat.info("public id of input stream is " +publicId);

    // Get system id from xml_catalog table

    String systemId = DBEntityResolver.getDTDSystemID(publicId);

    logMetacat.info("system id of input stream from xml_catalog"

                               +"table is " +systemId);

    //set system id to input stream

    xml.setSystemId(systemId);

  }

  /*

   * removes the DOCTYPE element and its contents from a Sting

   * used to avoid problems with incorrect SystemIDs

   */

  private String removeDOCTYPE(String in) {

    String ret = "";

    int startpos = in.indexOf("<!DOCTYPE");

    if (startpos>-1) {

      int stoppos = in.indexOf(">", startpos + 8);

      ret = in.substring(0,startpos) + in.substring(stoppos+1,in.length());

    } else {

      return in;

    }

    return ret;

  }

  /**

   * the main routine used to test the transform utility.

   *

   * Usage: java DBTransform

   */

  static public void main(String[] args) {

     if (args.length > 0)

     {

        System.err.println("Wrong number of arguments!!!");

        System.err.println("USAGE: java DBTransform");

        return;

     } else {

        try {

          // Open a connection to the database

          /*MetaCatUtil   util = new MetaCatUtil();

          Connection dbconn = util.openDBConnection();*/

          // Create a test document

          StringBuffer testdoc = new StringBuffer();

          testdoc.append("<?xml version=\"1.0\"?>");

          testdoc.append("<eml-dataset><metafile_id>NCEAS-0001</metafile_id>");

          testdoc.append("<dataset_id>DS001</dataset_id>");

          testdoc.append("<title>My test doc</title></eml-dataset>");

          // Transform the document to the new doctype

          DBTransform dbt = new DBTransform();

          dbt.transformXMLDocument(testdoc.toString(),

                                   "-//NCEAS//eml-dataset//EN",

                                   "-//W3C//HTML//EN",

                                   "knb",

                                   new PrintWriter(System.out), null);

        } catch (Exception e) {

          System.err.println("EXCEPTION HANDLING REQUIRED");

          System.err.println(e.getMessage());

          e.printStackTrace(System.err);

        }

     }

  }

  private void dbg(int position) {

    System.err.println("Debug flag: " + position);

  }

}