source: MDService2/branches/MDService_simple3/src/eu/clarin/cmdi/mdservice/action/RepoAction.java @ 1525

package eu.clarin.cmdi.mdservice.action;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.xml.transform.TransformerException;

import net.sf.json.JSON;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
//import net.sf.saxon.Controller;
//import net.sf.saxon.event.MessageEmitter;


import org.apache.log4j.Logger;
import org.apache.struts2.interceptor.ServletRequestAware;
import com.opensymphony.xwork2.ActionSupport;

import eu.clarin.cmdi.mdservice.internal.Cache;
import eu.clarin.cmdi.mdservice.internal.NoStylesheetException;
import eu.clarin.cmdi.mdservice.model.Diagnostic;
import eu.clarin.cmdi.mdservice.model.Diagnostics;
import eu.clarin.cmdi.mdservice.model.WorkspaceProfile;
import eu.clarin.cmdi.mdservice.proxy.MDRepoProxy;
import eu.clarin.cmdi.mdservice.proxy.Pz2Proxy;
import eu.clarin.cmdi.mdservice.proxy.SRUProxy;

/**
 * a Struts2 controller, responsible for calls to repositories.
 * After 2011-09 rework Action and Proxy are decoupled.
 * So Action calls appropriate Proxy based upon the target repository type
 * 
 * responds to requests (collections, model, recordset) 
 * by dispatching the requests to appropriate Proxy 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 RepoAction extends GenericAction 
//implements ServletRequestAware 
{

        private static final long serialVersionUID = 1L;
        private static Logger log = Logger.getLogger("RepoAction");
        
        /** 
         * Properties to be filled by Struts with according request-parameters
         */     
        private String actionkey;
        
        private String squery;  
        private String collection;
        private String columns;
        private String startItem;
        private String maximumItems;
        private String sort;    
        private int maxdepth;   
        //private String format="xml"; // default no transformation
        private String options;

        //private Map<String,Object> session;
        protected URL base_url ;

        @Override
        public String getFullFormat() {         
                return actionkey + "2" + getFormat();
        }
        /**
         * Based on the repository type - we create a typed Proxy, that will do the work.
         * If the type is not recognized - that is a bad user error    
         */
                public void setTargetProxy(){
                                                
                        //if (getRepository()==null) setRepository("clarin.at-mirror");
                        
                        switch (WorkspaceProfile.RepositoryType.toRepositoryType(WorkspaceProfile.getRepositoryType(getRepository())))
                        {               
                            case PAZPAR: 
                                setTargetProxy(new Pz2Proxy());
                                return;
                            case SRU:
                                setTargetProxy(new SRUProxy());
                                return;
                            case MD:
                                setTargetProxy(new MDRepoProxy());
                                return;
                            default:
                                getDiagnostics().Add(Diagnostic.MANDATORY_NOTSUPPLIED, "repository", "repository=" + getRepository() );
                        }
                        
                }
        /*
        public String getSquery() {
                return squery;
        }

        public void setSquery(String psquery) {
                if (psquery==null) psquery="";
                this.squery = psquery;
        }
        
        public String getCollection() {
                return collection;
        }

        public void setCollection(String collection) {
                this.collection = collection;
        }
        
        //TODO defaults
        public String getColumns() {
                String cols = columns;
                return cols;
        }

        public void setColumns(String columns) {
                this.columns = columns;
        }
        
        public int getMaxdepth() {
                return maxdepth;
        }

        public void setMaxdepth(int maxdepth) {
                this.maxdepth = maxdepth;
        }
/*
        public String getFormat() {
                return format;
        }

        public void setFormat(String format) {
                this.format = format;
        }

        public String getOptions() {
                return options;
        }

        public void setOptions(String options) {
                this.options = options;
        }

        
        public String getActionkey() {
                return actionkey;
        }

        public void setActionkey(String actionKey) {
                actionkey = actionKey;
        }

        
        public String getStartItem() {
                return startItem;
        }

        public void setStartItem(String startItem) {
                this.startItem = startItem;
        }

        public String getMaximumItems() {
                return maximumItems;
        }

        public void setMaximumItems(String maximumItems) {
                this.maximumItems = maximumItems;
        }
        

        public String getSort() {
                return sort;
        }

        public void setSort(String sort) {
                this.sort = sort;
        }
*/

        /**
         * internal identification of the target-proxy
         * base for finding the right base_url in the properties
         * subclass has to override with its specific proxykey
         * @return the key identifying this type of proxy
         */
        public String getProxyKey() {
                return "";
        }
                
        /**
         * Constructs an unambiguous key for the request (encoding all the parameters).
         * This is used as identifier for caching 
         * @return key unambiguously encoding the request
         */
        /*
         public String getRequestKey() {
                        String key="";
                        if (getActionkey()!=null) {
                                key += getActionkey() + "//-" ;
                        }else {
                                key +="//-" ;
                        }
                        if (getQ()!=null) {
                                key += getQ() + "//-" ;
                        } else {
                                key +="//-" ;
                        }
                        if (getCollection()!=null) {
                                key += getCollection() + "//-";
                        } else {
                                key +="//-" ;
                        }
                        if (getSquery()!=null) {
                                key += getSquery() + "//-" ;
                        } else {
                                key +="//-" ;
                        }
                        if (getStartItem()!=null) {
                                key += getStartItem() + "//-";
                        }
                                else{
                                        key +="//-" ;
                        }
                        if (getMaximumItems()!=null) {
                                key += getMaximumItems() + "//-";
                        }
                        else{
                                key +="//-" ;
                        }
                        
                        key += getRepository()  + "//-";
                        key += getMaxdepth()  + "//-";
                        
                        if (getLang()!=null) {
                                key += getLang() + "//-";
                        }else{
                                key +="//-" ;
                        }                       
                         
                return key;
        }
         */
        /*      
         @Override
        public Map<String,String> createTransformerParams(){
                
                Map<String, String> map = new HashMap<String, String>();

                Set<Entry<String, String[]>> set = getParams().entrySet();
                Iterator<Entry<String, String[]>> i = set.iterator();

            while(i.hasNext()){
              Map.Entry<String,String[]> e = (Map.Entry<String,String[]>)i.next();
              if (xsl_map.containsKey((String)e.getKey())) {
                  map.put(xsl_map.get((String)e.getKey()), (String)e.getValue()[0]);
              }
              
            }
            return map;
            */
            /*
                HashMap<String,String> hm = new HashMap<String,String>();
                
            if (getFullFormat() != null){
                        hm.put("format", getFullFormat());
            }
                if (getColumns() != null){
                        hm.put("cols", getColumns());
                } else {
                        hm.put("cols", "");
                }
                if (getStartItem() != null){
                        hm.put("startItem", getStartItem());
                }
                if (getMaximumItems() != null){
                        hm.put("maximumItems", getMaximumItems());      
                }
                if (getLang() != null){
                        hm.put("lang", getLang());
                }
                if (getQ() != null){
                        hm.put("q", getQ());
                }
                //if (getRepository() != null){
                hm.put("repository_name", String.valueOf(getRepository()));
                hm.put("repository_type", WorkspaceProfile.getRepositoryType(this.getRepository()));
                //}
        
                return hm;
        }
                */
        
        

}