source: MDService2/branches/MDService_simple3/src/eu/clarin/cmdi/mdservice/action/GenericAction.java @ 1517

package eu.clarin.cmdi.mdservice.action;

import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;

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.MDTransformer;
import eu.clarin.cmdi.mdservice.internal.NoStylesheetException;
import eu.clarin.cmdi.mdservice.model.Diagnostics;
import eu.clarin.cmdi.mdservice.proxy.ProxyInterface;



/**
 * main Struts2 controller (ie implemenets the struts' execute()-method), all other Actions are derived from.   
 * Defines the methods used for retrieving the data 
 * and provides basic implementation where possible.
 * Also responsible for caching and transformation of the result. 
 *  
 * @author vronk
 */
public class GenericAction extends ActionSupport 
implements ServletRequestAware 
{
        public static Logger log = Logger.getLogger("GenericAction");
        private static final long serialVersionUID = 1L;
        
        
        private Diagnostics diagnostics;
        /** 
         * Properties to be filled by Struts with according request-parameters
         */     
        private String actionkey = "generic";
        private String cache = Cache.SKIP;
        private String lang="en";
        private String q;
        private String format="xml"; // default no transformation
        private String actionContentType;
        private String userMsg;
        private HttpServletRequest request; 
        private long duration = 0;
        private String repository;
        private InputStream resultStream;
        private InputStream sourceStream;
        
        private Map<String,String[]> params;
        
//      protected URL base_url ;
        
        private ProxyInterface target_proxy;
                
                                
        public ProxyInterface getTargetProxy() {
                return target_proxy;
        }

        public void setTargetProxy(ProxyInterface proxy) {
                target_proxy = proxy;
                target_proxy.setSourceAction(this);
        }

/**
 * Empty implementation, subclasses have to decide themselves, which proxy to take.
 */     
        public void setTargetProxy() {
}

         public Diagnostics getDiagnostics(){
                 if (diagnostics == null){
                         diagnostics  = new Diagnostics();
                 }
                 return this.diagnostics;
         }
         
         public void setDiagnostics(Diagnostics diagnostics){
                 this.diagnostics = diagnostics;
         }
         
         public String getCache() {
                return cache;
        }

        public void setCache(String cache) {
                this.cache = cache;
        }

        public String getFormat() {
                return format;
        }

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

        public void setQ(String pq) {
                if (pq == null) pq="";
                /*
                if (q != null){
                        if (q.trim().length() == 0){
                                q = null;
                        }
                }
                */
                this.q = pq;
        }


        public void setRepository(String repository) {
                this.repository = repository;
        }
        
        public String getRepository() {
                //default repository = 1 (set on init)
                return repository;
        }
        
        /**
         * is used in struts.xml to dynamically set the mime-type of the result, depending on the format-parameter
         * @return
         */
        public String getActionContentType() {
                if (format.toLowerCase().startsWith("html")) {
                        this.actionContentType = "text/html";           
                        //this.actionContentType = "application/xhtml+xml";
                } else {
                        this.actionContentType = "text/xml";
                }
                
                return actionContentType;
        }

        public void setActionContentType(String actionContentType) {
                this.actionContentType = actionContentType;
        }
        
        public String getActionkey() {
                return actionkey;
        }

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

        public String getLang() {
                return lang;
        }

        public void setLang(String lang) {
                this.lang = lang;
        }

        public String getFullFormat() {         
                return actionkey + "2" + format;
        }


        /**
         * TODO: this should be replaced by the diagnostics-mechanism
         * @return
         */
        public String getUserMsg() {
                return userMsg;
        }

        public void setUserMsg(String userMsg) {
                this.userMsg = this.userMsg + "\n" + userMsg;
        }
        
        /**
         * TODO: check what this does, where it is used?
         * @return
         */
        @Override
        public void setServletRequest(HttpServletRequest arg0) {
                request = arg0;
        }

        public HttpServletRequest getServletRequest() {
                return request; 
        }

        /**
         * The stream holding the resulting data to be sent back to the user as response
         * @return
         */
        public InputStream getResultStream() {
                return resultStream;
    }
        public void setResultStream(InputStream _resultStream){
                resultStream = _resultStream;
        }
        public void setSourceStream(InputStream _sourceStream){
                sourceStream = _sourceStream;
        }
        
         
        /**
         * Get the sourceStream from the target proxy    
         * @return
         * @throws IOException
         * @throws NoStylesheetException
         */
                public InputStream getSourceStream() throws IOException, NoStylesheetException {                
                        return getTargetProxy().getSourceStream(); 
                }
                
        /**
         * Reads in all the parameters of the request into an internal structure.
         * the Map is not Map<String,String>, but rather Map<String,String[]>, 
         * ie the value is an array of Strings!
         * http://download.oracle.com/docs/cd/E17802_01/webservices/webservices/docs/1.5/api/javax/servlet/ServletRequest.html#getParameterMap%28%29
         * 
         * This shall allow more flexibility in using the parameters in the subclasses (and less getter/setter stuff)
         * at the cost of circumventing the Struts-way.
         */
        @SuppressWarnings("unchecked")
        protected void loadParams() {
                params = getServletRequest().getParameterMap();
        }

        public Map<String,String[]> getParams() {               
                return params;
        }

        
        /**
         * This is for simplified access to the the values of the request-parameters 
         * They are stored in the parameters-map as a String-array, 
         * but in most(?) situations, we expect just a simple string. 
         * @param key
         * @return
         */
        public String getParam(String key) {
                String v = "";
                if (!(params.get(key)==null)) v=(String)params.get(key)[0];
                return v;
        }

        public String[] getParamArray(String key) {
                String[] a = null;
                if (!(params.get(key)==null)) a=(String[])params.get(key);
                return a;
        }

        /**
         * 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;
        }
        
         
        public String addDurationKey(){
                String req_key = getRequestKey();
        
                Double duration_d;

            duration_d = (double)duration; 
            duration_d = duration_d/1000.0;
                req_key += duration_d + "//-";
                return req_key;
        }
        
        public HashMap<String,String> createTransformerParams(){
                
                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;
                
        }
        
        /**
         * This is the work-horse function.
         * It does two things: 
         * a) check if the source data is already in cache (based on cache-key that is constructed from the request parameters)
         * b) if format-parameter provided, invokes the transformation. 
         * at the end the data to be returned as result is contained in the resultStream
         * If format is xml, then the data from sourceStream is passed further as resultStream. 
         *    
         * @throws Exception  This is handled by struts (is mapped to some result in struts.xml based on the Exception-Class)
         */
        
        public void prepare() throws Exception {
                        
                loadParams();
                setTargetProxy();
                getTargetProxy().checkParams();
                
                String req_key = getRequestKey();
                log.debug("request_key: " +  req_key); 
                log.debug("params.size: " +  params.size());
                log.debug(getActionkey() + ".targetURL: " + getTargetProxy().getTargetRequest() + " .format:" + getFullFormat());
                
                // Caching
                String xcid;
        
                if (getCache().equals(Cache.SKIP)) {
                        
                        sourceStream = getSourceStream();
                        
                } else { 
                        if (getCache().equals(Cache.USE)) {
                                        sourceStream = Cache.getCache().getFromCache(req_key);
                        }
                        if (sourceStream == null) { // either not in cache or cache_flag=refresh
                                //sourceStream = getTargetRequest().openStream();
                                long startMillis = System.currentTimeMillis();
                                sourceStream = getSourceStream();
                                duration = System.currentTimeMillis() - startMillis;
                                req_key = addDurationKey();
                                
                                long now = System.currentTimeMillis();
                                xcid = Cache.getCache().putInCache(req_key,sourceStream);                       
                                //Admin.notifyUser("putting in cache: " + req_key);                     
                                sourceStream = Cache.getCache().getFromCache(req_key);
                        } /* else {
                                Admin.notifyUser("reading from cache: " + req_key);
                        } */
                }
                        
                if (getFormat().equals("xml")) {                        
                        resultStream = sourceStream;    
                }else {
                        MDTransformer transformer = new MDTransformer();
                        // set URL as srcFile (for MDTransformer to pass to xsl-scripts)
                        // TODO: WHY??
                        transformer.setSrcFile(getTargetProxy().getTargetRequest());
                        transformer.setParams(createTransformerParams());
                        // here the transformation is invoked
                        resultStream = transformer.transformXML(sourceStream);
                }
                
                log.debug(getActionkey() + " success:" + (resultStream!=null));
        }

        /**
         * default Action method that gets called by Struts. Everything interesting happens in prepare()
         */
        public String execute() throws Exception {
//              HttpServletRequest request = ServletActionContext.getRequest();
                //Admin.notifyUser("session-attrs:");
        //Admin.notifyUser(getServletRequest().getRemoteUser() );
        //Admin.notifyUser(String.valueOf(getSession()));
        
        long now = System.currentTimeMillis();

                prepare();
                long duration = (System.currentTimeMillis() - now);
                //duration

                if (resultStream == null) {
                        return ERROR;   
                } else {
                        return SUCCESS;
                }               
        }


}