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

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
 *    
 * 
 * @author vronk
 *
 */

public class MDTransformer {

        private URL srcFile ;
        private HashMap<String,String> params;
                
        private MDTransformer singleton;
        TransformerFactory tfactory ; 
        
        public MDTransformer () {               
                tfactory = TransformerFactory.newInstance();    
        }
        
        /*
        public static MDTransformer getMDTransformer () {
                if (singleton == null) {
                        singleton = new MDTransformer();
                } 
                return singleton;
        }
        */
        
        public URL getSrcFile() {
                return srcFile;
        }

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

        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
         * @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;
        }

        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);

                //Admin.notifyUser(this.getClass().getClassLoader().getResource(xslPath).toString());
                //Admin.notifyUser(this.getClass().getClassLoader().getResource(xslPath).getPath());
                
                
                streamSource.setSystemId(this.getClass().getClassLoader().getResource(xslPath).toString());
                return streamSource ;           
                
        }

        public Object getCols() throws TransformerConfigurationException, TransformerFactoryConfigurationError{
                
                String xmlString = null;
                // create new document
                Document doc = null;
                DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder;
                try {
                        docBuilder = docFactory.newDocumentBuilder();
                        doc = docBuilder.newDocument();
                        // append root tag <col >
                        Element root = (Element) doc.createElement("root");
                        doc.appendChild(root);
                        
                        Element child1 = (Element) doc.createElement("col");
                        child1.setTextContent("Id");
                        root.appendChild(child1);                       
                        Element child = (Element) doc.createElement("col");
                        child.setTextContent("Name");
                        root.appendChild(child);
                        //Element child = doc.createElement("col");
                        //child.setNodeValue("Id");
                        
                        
                        Transformer transformer = TransformerFactory.newInstance().newTransformer();
                        transformer.setOutputProperty(OutputKeys.INDENT, "yes");

                        //initialize StreamResult with File object to save to file
                        StreamResult result = new StreamResult(new StringWriter());
                        DOMSource source = new DOMSource(doc);
                        try {
                                transformer.transform(source, result);
                                xmlString = result.getWriter().toString();
                                
                                Admin.notifyUser(xmlString);
                        } catch (TransformerException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }

                        

                } catch (ParserConfigurationException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                //return xmlString;
                //return doc.getElementsByTagName("col").item(0);
                return doc.getDocumentElement();
        }
        
        public String getTranskey(){
                return params.get("format");
        }
        
        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());
               
/*              transformer.setParameter("q", q);
                transformer.setParameter("lang", lang);
                transformer.setParameter("format", transkey);
                transformer.setParameter("cols", cols);
                if ((startRecord != null) && (maximumRecords != null)) {

                        transformer.setParameter("startRecord", startRecord);
                        transformer.setParameter("maximumRecords", maximumRecords);
                }
                if (repositoryURI != null) {

                        transformer.setParameter("repository_uri", repositoryURI);
                }
                */
                /*       transformer.setParameter("cols", "<col label='id'>Id</col>" +
                                                                                 "<col label='id'>idno</col>" +
                                                                                 "<col label='name'>Name</col>" +
                                                                                 "<col label='title'>Title</col>" +
                                                                                 "<col label='title'>title</col>"); */
                
                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());          
            }
        
        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();
                }

        }
        /**
         * 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);
                //transformXML(xmlStream, transkey, cols, startRecord, maximumRecords, lang, q, repositoryURI, out);            
            InputStream transformedStream = new ByteArrayInputStream(out.toByteArray());
            //Admin.notifyUser("transformedStream:" + transformedStream.toString());
            return transformedStream;
        }
        
        /**
         * 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
         */
        /*
        public InputStream transformXML ( InputStream xmlStream, String transkey) throws IOException, InterruptedException, TransformerException {
                
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                transformXML(xmlStream, transkey, "", "", "","","", "", out);           
            InputStream transformedStream = new ByteArrayInputStream(out.toByteArray());
            //Admin.notifyUser("transformedStream:" + transformedStream.toString());
            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 present as string.
         * if xml in a file or a stream, use the other methods 
         * @param xml xml 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()));
/* instead of:
                InputStream  xslIS       =
                    new BufferedInputStream(new FileInputStream(getXSLPath(transkey)));
                
                Transformer transformer =
                    tfactory.newTransformer(new StreamSource(xslIS));
                    */
                ////////////////////
                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;
        }

        
        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;
        }
}