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

package eu.clarin.cmdi.mdservice.action;

import eu.clarin.cmdi.mdservice.action.Helpers;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

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

        /**
         * 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, 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("format", transkey);
                
                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 );
                        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) 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;
        }

}