source: MDService2/trunk/MDService2/src/eu/clarin/cmdi/mdservice/action/MDRepoProxyAction.java @ 890

package eu.clarin.cmdi.mdservice.action;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.io.StringWriter;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.HashMap;
import java.io.ByteArrayInputStream;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

import eu.clarin.cmdi.mdservice.model.Query;

/**
 * Main Struts 2 controller 
 * responds to requests (collections, model, recordset) 
 * by dispatching the requests to appropriate internal methods and filling the inputStream with the result
 *  
 * @author vronk
 *
 */
public class MDRepoProxyAction extends GenericProxyAction {

        private static final long serialVersionUID = 1L;

        private String proxy_key = "mdrepository";
        
        
        @Override
        public String getBaseURI() {            
                Admin.notifyUser("MDREPO-property:" + Admin.getConfig().getProperty(getProxyKey() + ".uri"));
                Admin.notifyUser("MDREPO-profile:" + getRepositoryPath());
                String uri = getRepositoryPath();//Admin.getConfig().getProperty(getProxyKey() + ".uri");               
                return uri;
        }
        
        @Override
        public void setFormat(String format) {
                super.setFormat(format);                
        }
        @Override
        public String getProxyKey() {
                return proxy_key;
        }
        
        
        private final static HashMap<String,String> urls = new HashMap<String,String>();
         static
         {       urls.put("collection", "?operation=getCollections&collection=");
                 urls.put("model", "?q=");
                 urls.put("recordset", "?operation=searchRetrieve&query=");
                 urls.put("record", "?operation=searchRetrieve&query=");
         } 
        /*
         @Override
         public URL getBaseURL() throws MalformedURLException {         
                        if (base_url == null) {
                                base_url = new URL(Admin.getConfig().getProperty(getProxyKey() + ".uri"));
                                try {
                                        Admin.notifyUser("TEST-URLold:" + base_url.toURI());
                                } catch (URISyntaxException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                                base_url = new URL(getRepository());
                                try {
                                        Admin.notifyUser("TEST-URLnew:" + base_url.toURI());
                                } catch (URISyntaxException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }
                        return base_url;
                }
         */
         
        /**
         * uses base_url + url_pattern (parametrized by actionkey) to form a url
         * @return the URL to the component-file
         * @throws Exception 
         */
        public URL getTargetRequest() throws IOException {
        // URL targetURL =new URL( base_url, compname + ".xml");
                
                Admin.notifyUser("MDRPA.getQ:" + getSquery() + " and (" +  getQ() + ")");
                Admin.notifyUser("MDRPA.getActionkey:" + getActionkey());
                Admin.notifyUser("MDRPA.getMaxdepth:" + getMaxdepth());
                
                Query query = new Query(getSquery(), getQ(),getActionkey());
                if (query.isStatus(Query.PARSEERROR)) {
                        Admin.notifyUser("MDRPA.query.PARSEERROR:" + query.getMsg());
                        // pass this bad news to the client
                        setUserMsg(query.getMsg());
                        return null;
                } else {
                        query.setMaxdepth(getMaxdepth());               
                        query.setCollection(getCollection());
                        query.setColumns(getColumns());
                        query.setMaximumRecords(getMaximumRecords());
                        query.setStartRecord(getStartRecord());
                        //Admin.notifyUser("MDRPA.records:" + query.getStartRecord());
                        //Admin.notifyUser("MDRPA.records:" + query.getMaximumRecords());
                        URL targetURL = null;           
                        
                        targetURL =new URL( getBaseURL(), urls.get(getActionkey()) + query.toURLParam() );
                        Admin.notifyUser("MDRPA.targetURL:" + targetURL);
                return targetURL;
                }
        }

        
/* 
 * FOLLOWING ARE OBSOLETE METHODS 
 * for processing the requests and serving the results
 * they stay here for reference (as bad examples) temporarily
 * and can/shall be removed in the near future. 
 */
        
/**
 * serves the collections, passes the Request to MDRepositoryProxy
 * @return
 * @throws Exception
 */
        /*
        public String collections() throws Exception {
        
                Query query = new Query(getQ(),Query.COLLECTIONS);
                
//               inputStream = getMDRepo().getCollections(query);
                 
                return SUCCESS;
        }
*/
        /**
         * serves the model/terms, via Query.execute() and .getResult()
         * @return
         * @throws Exception
         */
/*
        public String model() throws Exception {
                
                Query query = new Query(getQ(), Query.MODEL, getCollection());
                        Admin.notifyUser(query.getTargetRequest().toString());
                        query.setMaxdepth(getMaxdepth());
                query.execute();                                
                        
                //inputStream = query.getResult().getResultStream(format);
                return SUCCESS;
        }
*/
        /**
         * the method for actual querying of MDRepository 
         * and getting back the MD-recordset
         * using Query-object (not asking MDRepository yet)
         *    
         * @return
         * @throws Exception 
         * @throws Exception
         */     
        /*
        public String recordset() throws Exception {
                
                Query query = new Query(getQ(), Query.RECORDSET, getCollection());
                        
                        Admin.notifyUser("recordset_target_uri:" + query.getTargetRequest().toString());                
                        query.execute();                                

//              String str =query.getResult().getHeader();              
                 
//              inputStream = new ByteArrayInputStream(str.getBytes());

//              inputStream = query.getResult().getResultStream(format);
                return SUCCESS;
                 
        }
        */
        
        @Override
        public void prepare() throws Exception{
                super.prepare();
                
        }
}