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

package eu.clarin.cmdi.mdservice.action;

import java.io.BufferedInputStream;
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.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.URL;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
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 org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * 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 static 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;
        }

        /**
         * get the path to the transform-xsl file from properties, based on the key
         * @param key
         * @return
         */
        private String getXSLPath (String key) {                
                String xslpath = "";
                String xslfilename= Admin.getConfig().getProperty("xsl." + key);
                
                if (xslfilename!=null) {                        
                        xslpath =  Admin.getConfig().getProperty("scripts.path") + xslfilename;
                } 
                Admin.notifyUser("xslfile:" + xslpath);
                return xslpath;
        }

        private StreamSource getXSLStreamSource (String key){           
                
                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();
        }
        
        /**
         * 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
         */             
        public void transformXML (InputStream in, String transkey, String cols, String startRecord, String maximumRecords, String lang, OutputStream out ) throws TransformerException, IOException {
        
                // 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(transkey));
                
                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);
                }
                /*       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('\\', '/');
                        } 
                        Admin.notifyUser("root_uri:" +  root_uri );
                        Admin.notifyUser("xsrcfile:" +  root_uri );
                        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 );
            }
        
        /**
         * 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, String cols, String startRecord, String maximumRecords, String lang) throws IOException, InterruptedException, TransformerException {
                
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                transformXML(xmlStream, transkey, cols, startRecord, maximumRecords, lang, 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
         */
        public InputStream transformXML (URL xmlFile, String transkey ) throws IOException, InterruptedException, TransformerException {
                srcFile= xmlFile;
                InputStream  xmlStream =
             new BufferedInputStream(new FileInputStream(xmlFile.getPath()));
            
                return transformXML ( xmlStream, transkey); 
        }


        /**
         * 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
         */
        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");
                TransformerFactory tfactory = TransformerFactory.newInstance();
                OutputStream os = new ByteArrayOutputStream();
                StreamResult stream = new StreamResult(os);
                // Create a transformer for the stylesheet.
                Transformer transformer = tfactory.newTransformer(
                                                getXSLStreamSource(transkey));
/* instead of:
                InputStream  xslIS       =
                    new BufferedInputStream(new FileInputStream(getXSLPath(transkey)));
                
                Transformer transformer =
                    tfactory.newTransformer(new StreamSource(xslIS));
                    */
                transformer.setParameter("format", transkey);
                
                //Admin.notifyUser("transformer.parmformat" + transformer.getParameter("format"));

                // 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")));
                
                result = os.toString(); 
                
                        } catch (TransformerException e) {
                                e.printStackTrace();
                        }
                        
                        return result;
        }

        

}