source: MDService2/trunk/MDService2/src/eu/clarin/cmdi/mdservice/action/MDTransformer.java

package eu.clarin.cmdi.mdservice.action;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.URL;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
//import javax.xml.transform.ErrorListener;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

//import ognl.IntHashMap.Entry;

import net.sf.saxon.event.MessageEmitter;
import net.sf.saxon.event.MessageWarner;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

//import com.icl.saxon.*;
//import com.icl.saxon.FeatureKeys;
//import com.icl.saxon.Loader;
//import com.icl.saxon.output.Emitter;


/**
 * Helper class, encapsulating the xsl-transformations handling.
 * The contract is, that the requester passes a key, which can be resolved to a xsl-script (momentary mapped in properties: Admin.getConfig())
 * 
 * Bad things happen, if the key or the appropriate xsl-file do not exist - well the client gets a diagnostic message.
 *    
 * 
 * @author vronk
 *
 */

public class MDTransformer {

        private URL srcFile ;
        private HashMap<String,String> params;
                
        // don't use singleton!! Bad things happen
        // private MDTransformer singleton;
        TransformerFactory tfactory ; 
        
        public MDTransformer () {               
                tfactory = TransformerFactory.newInstance();    
        }
        
        
        public URL getSrcFile() {
                return srcFile;
        }

        public void setSrcFile(URL srcFile) {
                this.srcFile = srcFile;
        }

        /**
         * This serves the caller (mainly GenericProxyAction.prepare())
         * to provide/fill the request parameters. 
         * They then get translated to stylesheet-parameters (in SetTransformerParameters()).
         * @return
         */
        public void setParams(HashMap<String,String> params){
                this.params = params;
        }
        
        
        public HashMap<String,String> getParams(){
                return this.params;
        }
        /**
         * get the path to the transform-xsl file from properties, based on the key (aka format-parameter)
         * @param key
         * @return
         * @throws NoStylesheetException - if no matching entry in properties could be found 
         */
        private String getXSLPath (String key) throws NoStylesheetException {           
                String xslpath = "";
                String xslfilename= Admin.getConfig().getProperty("xsl." + key);
                
                if (xslfilename!=null) {                        
                        xslpath =  Admin.getConfig().getProperty("scripts.path") + xslfilename;
                } else {
                        throw new NoStylesheetException("No Stylesheet found for format-key: " + key);
                }
                Admin.notifyUser("xslfile:" + xslpath);
                return xslpath;
        }

        /**
         * Tries to load the stylesheet based on the key.
         * This is done in two steps:
         * 1. try to resolve the key to a path
         * 2. get the xsl-file as a stream (and establish it as StreamSource) 
         * 
         * @param key The key identifying the stylesheet for the transformation as passed by GenericProxyAction.
         * @return the stylesheet to be applied (as StreamSource)
         * @throws NoStylesheetException If the stylesheet could not be located
         */
        private StreamSource getXSLStreamSource (String key) throws NoStylesheetException{              
                
                InputStream xslstream;
                                        
                //URL myURL = new URL (getXSLPath(key));
                //xslstream = myURL.openStream();
                String xslPath = getXSLPath(key);
                xslstream = this.getClass().getClassLoader().getResourceAsStream(xslPath);
                StreamSource streamSource = new StreamSource(xslstream);

                streamSource.setSystemId(this.getClass().getClassLoader().getResource(xslPath).toString());
                return streamSource ;   
                
        }
        
        public String getTranskey(){
                return params.get("format");
        }

        /**
         * Makes the request-parameters available in the stylesheets
         * by translating them to stylesheet-parameters
         * @param transformer
         */
        public void SetTransformerParameters(Transformer transformer){
                
                Set<Map.Entry<String,String>> set = params.entrySet();
                Iterator<Map.Entry<String,String>> i = set.iterator();

            while(i.hasNext()){
              Map.Entry<String,String> e = (Map.Entry<String,String>)i.next();
              transformer.setParameter((String)e.getKey(), (String)e.getValue());
            }
        }
        
        /**
         * The main method for transforming, applies the appropriate (based on the transkey) stylesheet on the xml-stream
         * and writes the result into the output stream.    
         * @param in InpuStream with xml  
         * @param transkey this defines the stylesheet to use and is also passed to the stylesheet as "format"-parameter 
         * @param out the stream to write the output to
         * @throws TransformerException
         * @throws IOException
         * @throws NoStylesheetException 
         */
        public void transformXML (InputStream in, OutputStream out ) throws TransformerException, IOException, NoStylesheetException {
        //public void transformXML (InputStream in, String transkey, String cols, String startRecord, String maximumRecords, String lang, String q, String repositoryURI, OutputStream out ) throws TransformerException, IOException {
        
                        System.setProperty("javax.xml.transform.TransformerFactory", "net.sf.saxon.TransformerFactoryImpl");
                // Create a transform factory instance.
                TransformerFactory tfactory = TransformerFactory.newInstance();
                //OutputStream os = new ByteArrayOutputStream();
                StreamResult stream = new StreamResult(out);
                
                // Create a transformer for the stylesheet.
                        //String xslpath = getXSLPath(transkey);                
                Transformer transformer = tfactory.newTransformer(
                                                                        getXSLStreamSource(getTranskey()));
                SetTransformerParameters(transformer);
                
                //MessageWarner gg = new net.sf.saxon.event.MessageWarner();
                MessageEmitter me = new net.sf.saxon.event.MessageEmitter();
                StringWriter w = new StringWriter();
                me.setWriter(w);
               ((net.sf.saxon.Controller)transformer).setMessageEmitter(me);//new net.sf.saxon.event.MessageWarner());

               
                if (srcFile!=null) {
                        
                        File f = new File(srcFile.getPath());
                            
                        //Admin.notifyUser("src:" + srcFile.getFile());
                        //Admin.notifyUser("fpath:" + f.getAbsolutePath());
                        String root_uri =  srcFile.toString();
                        String xsrcfile =  srcFile.getFile();
                        if  (srcFile.getProtocol().equals("file")) {
                                root_uri = "file:///" + f.getParent().replace('\\', '/');
                                xsrcfile = "file:///" + f.getPath().replace('\\', '/');
                        } 
                        // TODO repository-path -removed, bad formating
                        String[] xsrcfiles = xsrcfile.split("&repository=");
                        String[] root_uris = root_uri.split("&repository=");
                        xsrcfile = xsrcfiles[0];
                        root_uri = root_uris[0];
                        ///
                        
                        Admin.notifyUser("root_uri:" +  root_uri );
                        Admin.notifyUser("xsrcfile:" +  xsrcfile );
                        
                        transformer.setParameter("root_uri", root_uri );
                        transformer.setParameter("src_file", xsrcfile);
                } else {
                        Admin.notifyUser("transformXML(): srcFile not set!!");                          
                }
                // 
                StreamSource src =new StreamSource();                   
                src.setInputStream(in);
                // Transform the source XML to out-stream
                transformer.transform(src, stream );
                
                // Write <xsl:message>
                writeXslMessages(w);
                ///Admin.notifyUser(w.getBuffer().toString());          
   }
        

        /**
         * just a wrapper for the main method translating the output-stream into a input-stream (expected by the Controller-Actions to return as response)
         * @param xmlStream the source xml stream 
         * @param transkey 
         * @return result-stream (converted to InputStream)
         * @throws IOException
         * @throws InterruptedException
         * @throws TransformerException
         * @throws NoStylesheetException 
         */
        public InputStream transformXML ( InputStream xmlStream) throws IOException, InterruptedException, TransformerException, NoStylesheetException {
        //public InputStream transformXML ( InputStream xmlStream, String transkey, String cols, String startRecord, String maximumRecords, String lang, String q, String repositoryURI) throws IOException, InterruptedException, TransformerException {
                
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                transformXML(xmlStream, out);           
            InputStream transformedStream = new ByteArrayInputStream(out.toByteArray());
            return transformedStream;
        }
        
        /**
         * another wrapper for the main method allowing to directly pass a URL to the source-xml    
         * @param xmlFile URL of the source-file   
         * @param transkey
         * @return the result-stream (already converted to an InputStream) 
         * @throws TransformerException
         * @throws IOException
         * @throws NoStylesheetException 
         */
        public InputStream transformXML (URL xmlFile ) throws IOException, InterruptedException, TransformerException, NoStylesheetException {
        //public InputStream transformXML (URL xmlFile, String transkey ) throws IOException, InterruptedException, TransformerException {
                srcFile= xmlFile;
                InputStream  xmlStream =
             new BufferedInputStream(new FileInputStream(xmlFile.getPath()));
            
                return transformXML ( xmlStream); 
        }


        /**
         * this is for xml-data present as string (primarily the query string present as XCQL).
         * if xml in a file or a stream, use the other methods 
         * @param xml xml-data as string
         * @param transkey 
         * @return
         * @throws NoStylesheetException 
         * @throws IOException 
         */
        public String transformXML (String xml) throws NoStylesheetException {
        //public String transformXML (String xml, String transkey ) {
                String result="";
                try {
                // Create a transform factory instance.
                        System.setProperty("javax.xml.transform.TransformerFactory", "net.sf.saxon.TransformerFactoryImpl");
                        //System.setProperty("javax.xml.transform.TransformerFactory", "com.icl.saxon.TransformerFactoryImpl");
                TransformerFactory tfactory = TransformerFactory.newInstance();
                OutputStream os = new ByteArrayOutputStream();
                StreamResult stream = new StreamResult(os);
                // Create a transformer for the stylesheet.
                Transformer transformer = tfactory.newTransformer(
                                                getXSLStreamSource(getTranskey()));

                MessageEmitter me = new net.sf.saxon.event.MessageEmitter();
                StringWriter w = new StringWriter();
                me.setWriter(w);
                ((net.sf.saxon.Controller)transformer).setMessageEmitter(me);//new net.sf.saxon.event.MessageWarner());

                // Transform the source XML to System.out.
                StreamSource src =new StreamSource();        
                Reader reader  = new StringReader(xml);
                src.setReader(reader);
                
                transformer.transform(src, stream );
                                    //  new StreamResult(new File("Simple2.out")));
             // Write <xsl:message>
                writeXslMessages(w);
                  
                result = os.toString(); 
                
                        } catch (TransformerException e) {
                                e.printStackTrace();
                        }
                        
                        return result;
        }

        private void writeXslMessages(StringWriter w){
        
        byte[] bytes = w.getBuffer().toString().getBytes();
        InputStream is =  new ByteArrayInputStream(bytes);
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        String s;
                try {
                        while ((s = br.readLine()) != null){
                        Admin.notifyUser(s);
                }
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        
        public static HashMap<String,String> createParamsMap(String transkey){
                HashMap<String,String> hm = new HashMap<String,String>();
                
            if (transkey != null){
                        hm.put("format", transkey);
            }
            return hm;
        }
}