source: MDService2/branches/MDService_simple3/src/eu/clarin/cmdi/mdservice/proxy/RepoProxy.java @ 1569

package eu.clarin.cmdi.mdservice.proxy;

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.util.Map;
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.apache.log4j.Logger;
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.action.GenericAction;
import eu.clarin.cmdi.mdservice.action.RepoAction;
import eu.clarin.cmdi.mdservice.internal.CQLParseException;
import eu.clarin.cmdi.mdservice.internal.NoStylesheetException;
import eu.clarin.cmdi.mdservice.model.Diagnostic;
import eu.clarin.cmdi.mdservice.model.Query;
import eu.clarin.cmdi.mdservice.model.WorkspaceProfile;

/**
 * Base class for implementation of proxies to target systems.
 * This is now (after rework 2011-09) decoupled from the called Action. 
 * 
 * Defines the methods used for retrieving the data 
 * and provides basic implementation where possible.
 *
 * In contrast to base class BasicProxy RepoProxy tries to get the base_uri from WorkspaceProfile (based on the repository-parameter)
 *  
 * @author vronk
 *
 */
public class RepoProxy extends BasicProxy{

        private static final long serialVersionUID = 1L;
        private static Logger log = Logger.getLogger("RepoProxy");
 
        private String proxy_key = "repo";
                
        // should perhaps be RepoAction, but it gets complicated with the types
        private GenericAction source_action;
        
        
        public GenericAction getSourceAction() {
                        return source_action;
        }
        
/*      public RepoAction getSourceAction() {
                return source_action;
}*/
        
        @Override
        public void setSourceAction(GenericAction action) {             
                source_action = action;
                
        }
        
        /**
         * Convenience function to access the request-parameters in the Action  
         * @param key
         * @return
         */
        public String getParam(String key) {
                return getSourceAction().getParam(key);
        }
        
        public Map<String,String[]> getParams() {
                return getSourceAction().getParams();
        }
        
        public void checkParams() {
                // required Params
                // check and set defaults
                if (WorkspaceProfile.getRepositoryPath(getParam("repository")) == null) {
                        getSourceAction().getDiagnostics().Add(Diagnostic.UNSUPPORTED_PARAMETERVALUE, "repository");
                }
                if (getParam("repository")=="") {
                        getSourceAction().getDiagnostics().Add(Diagnostic.MANDATORY_NOTSUPPLIED, "repository");
                }
        }
        
        
        /**
         * identification of the target-proxy (type)
         * base for finding the right base_url in the props
         * subclass has to override with its specific proxykey
         * @return
         */
        public String getProxyKey() {                           
                        return proxy_key;               
        }

        /**
         * Override of the basic method provided by the super-class:
         * Read the repository-uri from the WorkspaceProfile based on the repository-parameter 
         */
                
        public String getBaseURI() {            
                String uri = WorkspaceProfile.getRepositoryPath(getSourceAction().getRepository());             
                return uri;
        }

        /**
         * Provides the base-URL specific to given target repository or registry 
         * @return
         * @throws MalformedURLException
         */     
        public URL getBaseURL() throws MalformedURLException {          
                URL base_url = new URL(getBaseURI());           
                return base_url;
        }
        
        
        public InputStream getSourceStream() throws IOException, NoStylesheetException, CQLParseException {
                return getTargetRequest().openStream();         
        }
 
         public String fullQueryString(){
                String  full_query_string= "TODO: construct fullQueryString";
                
                /* matej 20110903
                 *  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 full target-request URL to be sent to the target repository
         * @throws CQLParseException 
         * @throws Exception 
         */     
        public URL getTargetRequest() throws IOException, CQLParseException {
                 
                
                //URL targetURL =new URL( getBaseURL(), urls.get(getActionkey()) + query.toURLParam() );
                URL targetURL =getBaseURL();
                
                log.debug("getTargetRequest().targetURL:" + targetURL);
            return targetURL;
                
        }

        

}