source: MDService2/branches/MDService_simple/src/eu/clarin/cmdi/mdservice/action/RepoProxyAction.java @ 1510

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;
import eu.clarin.cmdi.mdservice.model.WorkspaceProfile;

/**
 * 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
 * 
 * It is possible to switch target-repository dynamically  (on every request). I.e. the client explicitly selects one of the repositories.
 *  
 * @author vronk
 *
 */
public class RepoProxyAction extends GenericProxyAction {

        private static final long serialVersionUID = 1L;

        private String proxy_key = "repository";
        private RepoProxyAction target_proxy;
        private RepoProxyAction source_action;
        
/**
 * Based on the repository type - we create a typed Proxy, that will do the work.
 * If the type is not recognized <this> will be also the target_proxy - 
 * TODO: check if it is sane, to work without a typed target_proxy   
 */
        protected void  initialize(){
                
                switch (WorkspaceProfile.RepositoryType.toRepositoryType(WorkspaceProfile.getRepositoryType(getRepository())))
                {               
                    case PAZPAR: 
                        target_proxy = new Pz2ProxyAction();
                    case SRU:
                        target_proxy = new SRUProxyAction();
                    case MD:
                        target_proxy = new MDRepoProxyAction();
                    default:
                        target_proxy = this;
                }
                target_proxy.setSourceAction(this);
                
        }
        
        public RepoProxyAction getTargetProxy() {
                return target_proxy;
        }

        public RepoProxyAction getSourceAction() {
                return source_action;
        }
        
        public void setSourceAction(RepoProxyAction p_source_action) {
                source_action = p_source_action;
        }
        
/** 
 * Pass the proxy_key of the actual target_proxy,
 * or the basic "repository" if the target_proxy is identical  
 */
        @Override
        public String getProxyKey() {
                if (target_proxy.equals(this)) {
                  return proxy_key;
                } else {                
                        return getTargetProxy().getProxyKey();
                }
        }

        /**
         * Override of the basic method provided by the super-class
         * Reading the repository-uri from the WorkspaceProfile based on the repository-parameter 
         */     
        @Override       
        public String getBaseURI() {            
                String uri = WorkspaceProfile.getRepositoryPath(getRepository());               
                return uri;
        }
        
        //TODO remove - just for tests
        @Override
        public String getCache() {
                switch (WorkspaceProfile.RepositoryType.toRepositoryType(WorkspaceProfile.getRepositoryType(getRepository())))
                {
                    case PAZPAR: 
                        return Cache.SKIP;
                    case SRU:
                        return Cache.SKIP;
                    case MD:
                        return super.getCache();
                    default:
                        return super.getCache();
                }
        }
        
        //TODO remove after xsl update
        @Override
        public String getFullFormat() {         
                switch (WorkspaceProfile.RepositoryType.toRepositoryType(WorkspaceProfile.getRepositoryType(getRepository())))
                {
                    case PAZPAR: 
                        return "pazpar22" + this.getFormat();
                    case SRU:
                        return "sru2" + this.getFormat();
                    case MD:
                        return super.getFullFormat();
                    default:
                        return super.getFullFormat();
                }
        }
        
        @Override
        public InputStream getSourceStream() throws IOException, NoStylesheetException {
        
                return getTargetProxy().getSourceStream();
                /*
                switch (WorkspaceProfile.RepositoryType.toRepositoryType(WorkspaceProfile.getRepositoryType(getRepository())))
                {
                    case PAZPAR: 
                        try {
                                        return getSourcePz2();
                                } catch (Exception e) {
                                        // TODO Auto-,generated catch block
                                        e.printStackTrace();
                                }
                    case SRU:
                        return super.getSourceStream();//getSourceSRU();
                    case MD:
                        return super.getSourceStream();
                    default:
                        return super.getSourceStream();
                }
                */
        }
 
         public String fullQueryString(){
                String full_query_string= this.getQ();
                        
                if (!getSquery().equals("") && !this.getQ().equals("")){
                                full_query_string = "(" + this.getSquery() + " ) and (" + this.getQ() + ")";
                        } else if (!this.getSquery().equals("")) {
                                full_query_string = this.getSquery();
                        } else if (!this.getQ().equals("")){
                                full_query_string = this.getQ();
                        } else {
                                full_query_string = "";
                        }
                
                return full_query_string;
         }
         

        /**
         * uses base_url + url_pattern (parametrized by actionkey) to form a url
         * @return the URL to the component-file
         * @throws Exception 
         */
         @Override
        public URL getTargetRequest() throws IOException {
        // URL targetURL =new URL( base_url, compname + ".xml");
                
                Admin.notifyUser("RPA.getQ:" + getSquery() + " and (" +  getQ() + ")");
                Admin.notifyUser("RPA.getActionkey:" + getActionkey());         
                
                
//              Query query = new Query(getSquery(), getQ(),getActionkey());

                 
                        URL targetURL = getTargetProxy().getTargetRequest();
                        // targetURL =new URL( getBaseURL(), urls.get(getActionkey()) + query.toURLParam() );
                        
                        //Admin.notifyUser("RPA.targetURL.query.toURLParam:" + query.toURLParam());
                        Admin.notifyUser("RPA.targetURL:" + targetURL);
                return targetURL;
                
        }



/*      @Override
        public URL getTargetRequest() throws IOException {
 
                switch (WorkspaceProfile.RepositoryType.toRepositoryType(WorkspaceProfile.getRepositoryType(getRepository())))
                {
                    case PAZPAR: 
                        return base_url;
                    case SRU:
                                try {
                                        return getTargetRequestSRU();
                                } catch (NoStylesheetException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                    case MD:
                        return super.getTargetRequest();
                    default:
                        return super.getTargetRequest();
                }
        }
        */
}