source: MDService2/branches/MDService_simple3/src/eu/clarin/cmdi/mdservice/action/FCSAction.java @ 1832

package eu.clarin.cmdi.mdservice.action;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

import javax.xml.parsers.ParserConfigurationException;
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 org.w3c.dom.Document;
import org.w3c.dom.Node;

import eu.clarin.cmdi.mdservice.internal.CQLParseException;
import eu.clarin.cmdi.mdservice.internal.Cache;
import eu.clarin.cmdi.mdservice.internal.NoStylesheetException;
import eu.clarin.cmdi.mdservice.internal.Utils;
import eu.clarin.cmdi.mdservice.model.Diagnostic;
import eu.clarin.cmdi.mdservice.model.FCSRepositories;
import eu.clarin.cmdi.mdservice.model.Query;
import eu.clarin.cmdi.mdservice.model.Repositories;
import eu.clarin.cmdi.mdservice.model.WorkspaceProfile;
import eu.clarin.cmdi.mdservice.proxy.FCSProxy;
import eu.clarin.cmdi.mdservice.proxy.MDRepoProxy;
import eu.clarin.cmdi.mdservice.proxy.Pz2Proxy;
import eu.clarin.cmdi.mdservice.proxy.SRUProxy;
import eu.clarin.cmdi.mdservice.proxy.WorkspaceProxy;




public class FCSAction extends SRUAction 
{

        private static final long serialVersionUID = 1L;
        
        /** 
         * Properties to be filled by Struts with according request-parameters
         */     
        /*
        private String q;
        private String version;
        private String operation;
        private String query;
        private String scanClause;
        private int startRecord;
        private int maximumRecords;
        private String recordPacking;
        private String recordSchema;
        private String recordXPath;
        private int resultSetTTL;
        private String sortKeys;
        private String stylesheet;      
        private String x_cmd_repository;
        private String x_cmd_collections;
        private Set paramSet;
*/
        private String x_content;
        private Map<String,String[]> fcsparams;
        
        private static int OP_SEARCHRETRIEVE = 1;
        private static int OP_EXPLAIN = 2;
        private static int OP_SCAN = 3;
        
        
        //TODO cache after analysis ?
        @Override
        public String getCache() {
                return Cache.SKIP;
        }
        
        
        @Override
        public String getRepository() {
                if (getParam("operation").equals("searchRetrieve") && !getParam("x-context").equals("")){
                        if (FCSRepositories.getFCSRepositories().getFCSMapping(params.get("x-context")[0]) == null){
                                                return getParam("x-context");
                                        } else {
                                                return FCSRepositories.getFCSRepositories().getFCSMapping(params.get("x-context")[0]);
                                        }
                }
                return getParam("x-context");

        }

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

        @Override
        public String getFullFormat() {         
                return getActionkey() + getOperation() + "2" + getFormat();
        }
        
        public void addFCSParam(String key, String value){
                String[] sarr = new String[1];
                sarr[0] = value;
                fcsparams.put(key, sarr);       
        }
        public Map<String, String[]> getFCSParams(){
                if (fcsparams == null){

                        fcsparams = new HashMap<String, String[]>();
                        
                        if ( params.get("operation") != null){
                                addFCSParam("operation",params.get("operation")[0]);
                        }
                        if ( params.get("scanClause") != null){
                                addFCSParam("scanClause",params.get("scanClause")[0]);
                        }
                        if ( params.get("query") != null){
                                addFCSParam("query",params.get("query")[0]);
                        }
                        if ( params.get("x-context") != null){
                                /*if (WorkspaceProfile.getFCSMapping(params.get("x-context")[0]) != null){
                                        addFCSParam("x-context",params.get("x-context")[0]);
                                }
                                */
                                
                        }
                
                }
                
                return fcsparams;
                
        }
        
        @Override
        public String getFormat() {
                if (getParams().get("x-format") == null){
                                return "xml";
                }
                return getParam("x-format");
                
        }
        
        @Override
        protected void setDefaultParams(){
                // set defaults
                
                        if (params.get("x-context") != null){
                                
                                // not for scan operation , search in fcs-mapping
                                if (!params.get("operation")[0].equals("scan")){
                                        if (FCSRepositories.getFCSRepositories().getFCSMapping(params.get("x-context")[0]) == null){
                                                addParam("repository",params.get("x-context")[0]);
                                        } else {
                                                addParam("repository",FCSRepositories.getFCSRepositories().getFCSMapping(params.get("x-context")[0]));
                                        }
                                }
                        }       

                addParam("fullformat",getFullFormat());
                
                if (params.get("scripts_url") == null){
                        addParam("scripts_url",Utils.getConfig("webscripts.uri"));
                }
                
                if (params.get("base_url") == null){
                        addParam("base_url",Utils.getConfig("base.uri"));
                }
                if (params.get("cache") == null){
                        addParam("cache",Cache.SKIP);
                } 
                
                if ((getRepository().equals("")) && (getParam("operation").equals("scan"))){
                        addParam("part","repositories");
                        addParam("extradata","fcs.resource");
                }
        }
        
        @Override
        public boolean checkTargetProxy(){
                return false;
        }
        
        @Override
        public void checkParams(){
                if (getTargetProxy() != null){
                        getTargetProxy().checkParams(); 
                }
        }
        @Override
        public String getUserName(){
                
                return WorkspaceProfile.SERVER;
        }
        @Override
        public void setTargetProxy(){
                
                //Query query = new Query();
                //TODO case scan,explain
                
                if ((getRepository().equals("")) && (getParam("operation").equals("scan"))){
                        setTargetProxy(new WorkspaceProxy());
                return;
                }
                
                switch (Repositories.RepositoryType.toRepositoryType(Repositories.getRepositories().getRepositoryType(getRepository())))
                {               
                    case PAZPAR: 
                        setTargetProxy(new Pz2Proxy(new Query(getActionkey(), this.getParams())));
                        return;
                    case SRU:
                        setTargetProxy(new SRUProxy(new Query(Query.SRUEXTERN,getParams())));
                        return;
                    case MD:
                        setTargetProxy(new MDRepoProxy(new Query(Query.RECORDSET,getParams())));
                        return; 
                    case FCS:
                        setTargetProxy(new FCSProxy(new Query(Query.FCSRECORDSET,getFCSParams())));
                        return;
                    case FCSRESOURCE:
                        setTargetProxy(new FCSProxy(new Query(Query.FCSRECORDSET,getFCSParams())));
                        return;
                    default:
                        //TODO error  = bad workspaceProfile configuration
                        getDiagnostics().Add(Diagnostic.SYSTEM_ERROR, "Error in workspaceprofile configuration", "repository=" + getRepository() );
                }
}
}