source: MDService2/trunk/MDService2/src/eu/clarin/cmdi/mdservice/action/WorkspaceAction.java @ 1310

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.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;

import java.io.StringReader;
import java.io.StringWriter;

import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
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 javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;


import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
import net.sf.json.xml.XMLSerializer;

import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
//import javax.servlet.ServletInputStream;


import org.apache.struts2.interceptor.ServletRequestAware;
import org.w3c.dom.Attr;
import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import com.opensymphony.xwork2.ActionSupport;


/**
 *
 * @author 
 *
 */
public class WorkspaceAction extends GenericProxyAction 
//implements ServletRequestAware 
{

        private static final long serialVersionUID = 1L;
        
        // workspaceprofiles
        public static String USER = "user";
        public static String SERVER = "server";
        // administration query identification
        public static String ADMIN = "admin";
        public static String FILENAME = "filename";
        
        public static String PROFILENAME_BASE = "WorkspaceProfile_";
        public static String PROFILENAME_SERVER = "WorkspaceProfileServer.xml";
        public static String PROFILENAME_DEFAULT = PROFILENAME_BASE + "default.xml";
        public static String ADMINISTRATION_FILENAME = "Administration.xml";
        
        private String workspace_filename = "WorkspaceProfile.xml";
        /** 
         * Properties to be filled by Struts with according request-parameters
         */     
        //private String actionkey;
        private String data;
        private String type;
        private String qid;
        //private String format;
        //private String userMsg;
        private String base_path;
        
        
        private static WorkspaceAction singleton;
        private static String workspacefilename;
        private static Document workspace_doc;
        
        //private String workspaceindex_path;
        //private static Integer querycounter;
        private static final Integer start_query = 1;
        
        
        
        //private HttpServletRequest request; 
        
        public String Workspace_filename(){
                return workspace_filename;
        }

        public void setWorkspace_filename(String workspace_filename) {
                this.workspace_filename = workspace_filename;
        }
        
        public String getData(){
                return data;
        }

        public void setData(String data) {
                this.data = data;
        }

        public String getType() {
                return type;
        }

        public void setType(String type) {
                this.type = type;
        }
        
        public String getQid() {
                return qid;
        }

        public void setQid(String qid) {
                this.qid = qid;
        }

        public WorkspaceAction () {             
                workspacefilename = Admin.getConfig().getProperty("workspaceprofile.path") + Admin.getConfig().getProperty("workspace.file");
                if (workspace_doc == null){
                        //workspacefilename = Admin.getConfig().getProperty("workspace.path") + Admin.getConfig().getProperty("workspace.file");
                        initDocument();
                }
        }
        
        public static WorkspaceAction getWorkspaceAction() {
                if (singleton == null) {
                        singleton = new WorkspaceAction();
                } 
                return singleton;
        }

        protected void finalize() throws Throwable {        
            try {               
                //updateQuerycounter();
                //saveDocument();
            } catch(Exception e) {
            }       
            finally {           
                super.finalize();
                //more code can be written here as per need of application              
            }
        }
        /**
         * primitive identification of the target-proxy
         * base for finding the right base_url in the props
         * subclass has to override with its specific proxykey
         * @return
         */
        public String getProxyKey() {
                return "workspaceprofile";
        }

        /*
        @Override
        public void setServletRequest(HttpServletRequest arg0) {
                request = arg0;
                
        }

        @Override
        public HttpServletRequest getServletRequest() {
                return request;         
        }
*/
        /*
        public String getUserMsg() {
                return userMsg;
        }

        public void setUserMsg(String userMsg) {
                this.userMsg = this.userMsg + "\n" + userMsg;
        }


        private InputStream resultStream;
        private InputStream sourceStream;
*/
        /**
         * The stream holding the resulting data to be sent back to the user as response
         * @return
         */
        /*
        public InputStream getResultStream() {
                return resultStream;
    }
        public void setResultStream(InputStream _resultStream){
                resultStream = _resultStream;
        }
        public void setSourceStream(InputStream _sourceStream){
                sourceStream = _sourceStream;
        }
        */
        @Override
        public URL getBaseURL() {
                File file=new File(getPath());
            URL url=null;
            try{
                    url=file.toURL(); 
                    Admin.notifyUser("DEBUG: WorkspaceAction.getBaseURL(): "  + url);
            } catch (MalformedURLException e){
                Admin.notifyUser("JSON exception has been caught" + e);
            }
            
            return url;
        }
        
        public String getBasePath() {           
                if (base_path == null) {
                        base_path = Admin.getConfig().getProperty(getProxyKey() + ".path");
                }
                return base_path;
        }
        
        
        public String getWorkspaceProfile() {
                String profilename = null;
                
                if (type.toLowerCase().equals(USER)) {
                        if (getServletRequest().getRemoteUser() != null) {
                                profilename =  PROFILENAME_BASE + getServletRequest().getRemoteUser() + ".xml";
                        } else {
                                profilename = PROFILENAME_DEFAULT;
                        }
                } else if (type.toLowerCase().equals(SERVER)) {
                        profilename =  PROFILENAME_SERVER;
                        /*
                        File f = new File(getBasePath() + profilename);
                        if (! f.exists()){
                                //Admin.notifyUser(" not exists");
                                profilename = "WorkspaceProfile_default.xml";
                        }
                        */
                } else if (type.toLowerCase().equals(ADMIN)){
                        profilename =  ADMINISTRATION_FILENAME;
                } else if (type.toLowerCase().equals(FILENAME)){
                        profilename = this.workspace_filename;
                }
                
                if (profilename == null){
                        profilename = PROFILENAME_DEFAULT;
                        Admin.notifyUser("WorkspaceProfilePath not specified (USER, SERVER)!");
                }
                
                Admin.notifyUser("WorkspaceProfilename : " + profilename);
                return profilename;
        }
        
        @Override
        public String getFullFormat() {
                return "xml2json";
        }
        
        public URL getURL() {
                File file=new File(getPath());
            URL url=null;
            try{
                    url=file.toURL(); 
                    //Admin.notifyUser("url "  + url);
            } catch (MalformedURLException e){
                //Admin.notifyUser("" + e);
            }
                return url;
        }
        
        
        public String getPath() {
                String targetPath = getBasePath() + this.workspace_filename;//getWorkspaceProfile();       
        Admin.notifyUser("WorkspaceAction TARGETPATH: " + targetPath);              
        return targetPath;
        }

        @Override
        public InputStream getSourceStream() throws IOException {       
                InputStream stream = new BufferedInputStream( new FileInputStream(getPath()));
        
                
                return   stream;
        }
        
        // set the server - session data =  repositories, termsets
        public void setSessionData(InputStream source) throws IOException {
                if (source == null) return;
                if (this.getWorkspaceProfile() != PROFILENAME_SERVER) return;
                
                
                        
        }
        
        /*
        @Override
        public void prepare() throws Exception {                
                
                //Admin.notifyUser("execute:");
                InputStream in = getSourceStream();
                this.setSourceStream(in); 
                if (getFormat().equals("xml")) {                        
                        setResultStream(in);    
                }else { //JSON
                        // set srcFile (for MDTransformer to pass to xsl-scripts) 
                        MDTransformer transformer = new MDTransformer();
                        transformer.setSrcFile(getURL());
                        transformer.setParams(MDTransformer.createParamsMap(getFullFormat()));
                        setResultStream(transformer.transformXML(in));//, getFullFormat()));
                        //setSessionData(getResultStream());
                }
                        
                Admin.notifyUser(getProxyKey() + " success:" + (getResultStream()!=null));
        }

        public void changeNodeName(Document doc, Node node, String new_name){
                // Create an element with the new name 
                Node node2 = (Node ) doc.createElement(new_name); 
                // Copy the attributes to the new element NamedNodeMap attrs = element.getAttributes(); for (int i=0; i<attrs.getLength(); i++) { Attr attr2 = (Attr)doc.importNode(attrs.item(i), true); element2.getAttributes().setNamedItem(attr2); } 
                // Move all the children 
                while (node.hasChildNodes()) { node2.appendChild(node.getFirstChild()); } 
                // Replace the old node with the new node
                Admin.notifyUser("replace:" + node2.getNodeName() + "," + node.getNodeName());
                node.getParentNode().replaceChild(node2, node); 
        }

        public void administrateQid() throws IOException, SAXException, ParserConfigurationException, TransformerException{
                WorkspaceAction wa = new WorkspaceAction();
                wa.setType("Admin");
                
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder;

                builder = factory.newDocumentBuilder();
                Document  document = builder.parse(wa.getSourceStream());
                // find user-filename-id or create one
                //add qid
                //NodeList list = document.getElementsByTagName("e");
                //Admin.notifyUser("list:" + list.getLength());

                // save the changes
                Transformer transformer;
                transformer = TransformerFactory.newInstance().newTransformer();
                transformer.setOutputProperty(OutputKeys.INDENT, "yes");
                StreamResult result = new StreamResult(new StringWriter());
                DOMSource source = new DOMSource(document);
                transformer.transform(source, result);
                String xmlString = result.getWriter().toString();
                InputStream is_xml = new ByteArrayInputStream( xmlString.getBytes( ) );
                Admin.writeToFile(wa.getPath(), is_xml);
                //wa.save();
        }
        
        public String save() throws IOException, SAXException, ParserConfigurationException, TransformerException {
                
        String jsonData = getData();
              
        Admin.notifyUser("JSON data:"+jsonData);
        if ((!this.getType().equals(ADMIN)) && this.getQid() != null) {
                        administrateQid();
                } 
        
        XMLSerializer serializer = new XMLSerializer();
                JSON json = JSONSerializer.toJSON( jsonData );
                if (this.getType().equals(ADMIN)){
                        serializer.setRootName("Admin");
                } else {
                        serializer.setRootName("WorkspaceProfile");     
                }
                serializer.setElementName("item");
        serializer.setTypeHintsEnabled(false); 
        String xml = serializer.write( json );
        Admin.notifyUser("XML:" + xml);
        
        InputStream is_xml = new ByteArrayInputStream( xml.getBytes( ) );
        
        Admin.writeToFile(getPath(), is_xml);
   
        String ret = "1";
                this.setResultStream( new ByteArrayInputStream(ret.getBytes()));
                                

                return SUCCESS;
        }
*/
        public void changeQueryId(Document doc, String from_id, String to_id) throws XPathExpressionException{
                InputStream is = null;
                XPathFactory factory = XPathFactory.newInstance(); 
            XPath xpath = factory.newXPath(); 
            XPathExpression expr;
            String xpath_expr = "";
                xpath_expr = "//WorkspaceProfile/Querysets/item/Queries/item/id[.='" + from_id + "']";
                expr = xpath.compile(xpath_expr);
                Object result = null;
                result = expr.evaluate(doc, XPathConstants.NODESET);
                
            NodeList nodelist = (NodeList) result;
            nodelist.item(0).setTextContent(to_id);
        }
        public String createNewQid(){
                String id = workspace_doc.getElementsByTagName("maxqid").item(0).getTextContent();
                Integer i = Integer.parseInt(id) + 1;
                id = i.toString();
                workspace_doc.getElementsByTagName("maxqid").item(0).setTextContent(id);
                return id.toString();
        }
        public InputStream createStream(String value) throws TransformerException, TransformerFactoryConfigurationError, ParserConfigurationException, UnsupportedEncodingException{
        DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = dbfac.newDocumentBuilder();
        Document doc = docBuilder.newDocument();

        ////////////////////////
        //Creating the XML tree
        Element root = doc.createElement("root");
        root.setTextContent(value);
        doc.appendChild(root);
        //set up a transformer
        TransformerFactory transfac = TransformerFactory.newInstance();
        Transformer trans = transfac.newTransformer();
        //trans.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
        //trans.setOutputProperty(OutputKeys.INDENT, "yes");

        //create string from xml tree
        //StringWriter sw = new StringWriter();
        //StreamResult result = new StreamResult(sw);
        //DOMSource source = new DOMSource(doc);
        //trans.transform(source, result);
        

        DOMSource source = new DOMSource(doc);   
        StringWriter xmlAsWriter = new StringWriter();   
        StreamResult result = new StreamResult(xmlAsWriter);     
        TransformerFactory.newInstance().newTransformer().transform(source, result);   
          
        // write changes   
        ByteArrayInputStream is = new ByteArrayInputStream(xmlAsWriter.toString().getBytes("UTF-8"));  
           

       return is;


        }
        public String save() throws ParserConfigurationException, SAXException, IOException, DOMException, XPathExpressionException, TransformerException, TransformerFactoryConfigurationError{
                
                // user data
                String jsonData = getData();
        XMLSerializer serializer = new XMLSerializer();
                JSON json = JSONSerializer.toJSON( jsonData );
                serializer.setRootName("WorkspaceProfile");     
                serializer.setElementName("item");
        serializer.setTypeHintsEnabled(false); 
        String xml = serializer.write( json );
        //Admin.notifyUser("XML:" + xml);
        InputStream is_xml = new ByteArrayInputStream( xml.getBytes( ) );
        // add to document
        //Admin.writeToFile(getPath(), is_xml);
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        Document d = builder.parse( is_xml );
        // set user
        //((Element)d.getFirstChild()).setAttribute("user", getServletRequest().getRemoteUser());
        NodeList wsnodelist = (NodeList) getWorkspace();
        // remove 
        //childeNode
        if (wsnodelist.getLength() > 0){
                ((Node)wsnodelist.item(0)).getParentNode().removeChild(wsnodelist.item(0));
        }
        String qidstring = "";
        if (qid.equals("0")) {
            qidstring = createNewQid();
            changeQueryId(d,qid,qidstring);
        }
        
        Node node = d.getFirstChild();
        Node node2 = workspace_doc.adoptNode(node.cloneNode(true));
        ((Element)node2).setAttribute("user", getUserName());
        workspace_doc.getElementsByTagName("WorkspaceProfiles").item(0).appendChild(node2);

      //TODO
        saveDocument();
        // return new qid
        //String src = "<body>" + qidstring + "</body>";
        //javax.xml.transform.stream.StreamSource s = new StreamSource(src);
        //InputStream in = s.getInputStream(); 
                this.setResultStream(createStream(qidstring));//(InputStream)(new ByteArrayInputStream(qidstring.getBytes())));
                
                
                return SUCCESS;
                
        }
        public InputStream DocumentToStream(Node node) throws TransformerConfigurationException, TransformerException, TransformerFactoryConfigurationError{
                
                InputStream is = null;
                ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); 
                Source xmlSource;
                
                if (node == null) {
                        xmlSource = new DOMSource(workspace_doc); 
                } else {
                        xmlSource = new DOMSource(node);
                }
                Result outputTarget = new StreamResult(outputStream); 
                TransformerFactory.newInstance().newTransformer().transform(xmlSource, outputTarget); 
                is = new ByteArrayInputStream(outputStream.toByteArray()); 
                return is;
        }

        public String DocumentToXMLString(){
                Transformer transformer;
                String xmlString = "";
                try {
                                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(workspace_doc);
                                try {
                                        transformer.transform(source, result);
                                } catch (TransformerException e1) {
                                        // TODO Auto-generated catch block
                                        e1.printStackTrace();
                                }

                                xmlString = result.getWriter().toString();
                        } catch (TransformerConfigurationException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        } catch (TransformerFactoryConfigurationError e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                        
                return xmlString;
        }
        
        public void addWorkspaceToDocument(){
                //{'WorkspaceProfile':{'CustomTermsets':'null',
                //                     'Termsets':'null',
                //                     'Repositories':'null',
                //                     'Querysets':'null','created':'null','lastchanged':'null','profilename':'null'}};
                Element we = workspace_doc.createElement("WorkspaceProfile");
                we.setAttribute("user", getType().toLowerCase());
                workspace_doc.getFirstChild().appendChild(we);
                
                Element e = workspace_doc.createElement("CustomTermsets");
                e.setNodeValue("null");
                we.appendChild(e);
                
                e = workspace_doc.createElement("Termsets");
                e.setNodeValue("null");
                we.appendChild(e);
                
                e = workspace_doc.createElement("Repositories");
                e.setNodeValue("null");
                we.appendChild(e);
                
                e = workspace_doc.createElement("Querysets");
                e.setNodeValue("null");
                we.appendChild(e);
                
                DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                String strdate = dateFormat.format(new Date()).toString();
                e = workspace_doc.createElement("created");
                e.setNodeValue(strdate);
                we.appendChild(e);
                
                e = workspace_doc.createElement("lastchanged");
                e.setNodeValue(strdate);
                we.appendChild(e);
                
                e = workspace_doc.createElement("profilename");
                e.setNodeValue(getType().toLowerCase());
                we.appendChild(e);
        }
        
        public String getUserName(){
                String userstring;
                if (getType().toLowerCase().equals(SERVER)){
                        userstring = SERVER;
                }else {
                        userstring = getServletRequest().getRemoteUser();
                        if (userstring == null){
                                userstring = "default";
                        }
                }
                return userstring;
        }
        public String getWorkspaceXPathExpression(){
                String xpath_expr = "";

                xpath_expr = "//Profiles/WorkspaceProfiles/WorkspaceProfile[@user='" + getUserName() + "']";

                return xpath_expr;
        }
        
        public Object getWorkspace() throws XPathExpressionException{
                InputStream is = null;
                XPathFactory factory = XPathFactory.newInstance(); 
            XPath xpath = factory.newXPath(); 
            XPathExpression expr;
                        expr = xpath.compile(getWorkspaceXPathExpression());
                        //expression is evaluated with respect to a certain context node which is doc.
                        Object result = null;
                        try{
                        result = expr.evaluate(workspace_doc, XPathConstants.NODESET);
                        } catch(Exception e){
                                
                        }

             return result;
        }
        
           
        @Override
        public void prepare() throws Exception {                
                
                NodeList list = (NodeList) getWorkspace();//result;
                if (list.getLength() < 1) {
                        addWorkspaceToDocument();
                        list = (NodeList) getWorkspace();
                }
                if (list.getLength() > 1){
                        // error
                }
                // nodelistto stream
                InputStream is = this.DocumentToStream(list.item(0));
                this.setSourceStream(is);     
                
                if (getFormat().equals("xml")) {                        
                        setResultStream(is);    
                }else { //JSON
                        // set srcFile (for MDTransformer to pass to xsl-scripts) 
                        MDTransformer transformer = new MDTransformer();
                        transformer.setSrcFile(getURL());
                        transformer.setParams(MDTransformer.createParamsMap(getFullFormat()));
                        setResultStream(transformer.transformXML(is));//, getFullFormat()));
                        //setSessionData(getResultStream());
                }
                        
                Admin.notifyUser(getProxyKey() + " success:" + (getResultStream()!=null));
        }

        
        
public void initDocument() {
        
        boolean init=false;
        Integer counter = start_query;
        //String fname = getPath();//workspacefile;
        File f = new File (workspacefilename);
                
        if (!f.exists()) {
                                // create new  counter document
                                DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
                        DocumentBuilder docBuilder;
                                try {
                                        docBuilder = docFactory.newDocumentBuilder();
                                        workspace_doc = docBuilder.newDocument();
                                        // append root tag <index >
                                        Element root = (Element) workspace_doc.createElement("Profiles");
                                        //root.setAttribute("idcounter", "1");
                                        workspace_doc.appendChild(root);
                                        Element e = workspace_doc.createElement("Querycounter");
                                        root.appendChild(e);
                                        e = workspace_doc.createElement("maxqid");
                                        e.setNodeValue(counter.toString());
                                        e = workspace_doc.createElement("WorkspaceProfiles");
                                        root.appendChild(e);

                                        //updateQuerycounter();
                                        this.saveDocument();
                                        
                                        //Admin.notifyUser("new document");
                                } catch (ParserConfigurationException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
            }
                else {
                        try {
                                
                        DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
                        DocumentBuilder docBuilder;
                                try {
                                        docBuilder = docFactory.newDocumentBuilder();               
                                        try {
                                                        workspace_doc = docBuilder.parse(workspacefilename);
                                        } catch (SAXException e) {
                                                        // TODO Auto-generated catch block
                                                        
                                                        e.printStackTrace();
                                        }
                                } catch (ParserConfigurationException e) {
                                                // TODO Auto-generated catch block
                                                e.printStackTrace();
                                }
                                
                         //read counter
                         //counter = new Integer(workspace_doc.getFirstChild().getFirstChild().getFirstChild().getNodeValue());
                         init = true;
                    }  catch (IOException ex){
                        //Admin.notifyUser("initCacheCounter:" + ex.toString());
                        ex.printStackTrace();
                    }
                }
                
            //return counter;
        }
/*
        public void updateQuerycounter () {
                workspace_doc.getFirstChild().getAttributes().getNamedItem("idcounter").setNodeValue(querycounter.toString());
            saveDocument();
        }
        */
        public void saveDocument() {
        //public void writeQuerycounter (Integer i) {           
                
                // first update <index idcounter>
                //workspace_doc.getFirstChild().getAttributes().getNamedItem("idcounter").setNodeValue(i.toString());
                
                //Admin.notifyUser("writeCacheCounter:" + i.toString());
                // write xml
                Transformer transformer;
                try {
                        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(workspace_doc);
                        try {
                                transformer.transform(source, result);
                        } catch (TransformerException e1) {
                                // TODO Auto-generated catch block
                                e1.printStackTrace();
                        }

                        String xmlString = result.getWriter().toString();

                        File f = new File (workspacefilename);
                        FileWriter fw;
                        try {
                                fw = new FileWriter(f);
                                try {
                                        fw.write(xmlString);
                                        fw.close();
                                } catch (IOException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }       
                        } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }
                } catch (TransformerConfigurationException e2) {
                        // TODO Auto-generated catch block
                        e2.printStackTrace();
                } catch (TransformerFactoryConfigurationError e2) {
                        // TODO Auto-generated catch block
                        e2.printStackTrace();
                }
        }
        

}