--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/gnv-artifacts/src/main/java/de/intevation/gnv/state/OutputStateBase.java	Fri Sep 28 12:13:53 2012 +0200
@@ -0,0 +1,431 @@
+/**
+ *
+ */
+package de.intevation.gnv.state;
+
+import java.io.OutputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+
+import javax.xml.xpath.XPathConstants;
+
+import net.sf.ehcache.Cache;
+
+import org.apache.log4j.Logger;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import de.intevation.artifactdatabase.Config;
+import de.intevation.artifactdatabase.XMLUtils; 
+import de.intevation.artifacts.CallContext;
+import de.intevation.artifacts.CallMeta;
+import de.intevation.gnv.artifacts.cache.CacheFactory;
+import de.intevation.gnv.artifacts.ressource.RessourceFactory;
+import de.intevation.gnv.geobackend.base.Result;
+import de.intevation.gnv.geobackend.base.query.QueryExecutor;
+import de.intevation.gnv.geobackend.base.query.QueryExecutorFactory;
+import de.intevation.gnv.geobackend.base.query.exception.QueryException;
+import de.intevation.gnv.state.describedata.MinMaxDescribeData;
+import de.intevation.gnv.state.exception.StateException;
+import de.intevation.gnv.utils.InputValidator;
+
+/**
+ * @author Tim Englich <tim.englich@intevation.de>
+ * 
+ */
+public abstract class OutputStateBase 
+extends               StateBase 
+implements            OutputState
+{
+    public static final String XPATH_OUTPUT_MODE =
+        "/art:action/art:out/@name";
+
+    public static final String XPATH_EXPORT_MODE =
+        "/art:action/art:out/art:export/@name";
+
+    public static final String XPATH_MIME_TYPE   =
+        "/art:action/art:out/art:mime-type/@value";
+
+    public static final String XPATH_EXPORTS =
+        "exportModes/export";
+
+    /**
+     * The UID of this Class
+     */
+    private static final long serialVersionUID = -1718732895737303823L;
+
+    /**
+     * the logger, used to log exceptions and additonaly information
+     */
+    private static Logger log = Logger.getLogger(OutputStateBase.class);
+
+    /**
+     * The different Outputmodes which are provided by an OutputState
+     */
+    protected Collection<OutputMode> outputModes = null;
+    
+    protected String queryODVID = null;
+
+    /**
+     * Constructor
+     */
+    public OutputStateBase() {
+        super();
+    }
+
+    /**
+     * @see de.intevation.gnv.state.OutputState#getOutputModes()
+     */
+    public Collection<OutputMode> getOutputModes() {
+        log.debug("OutputStateBase.getOutputModes");
+        return this.outputModes;
+    }
+
+    /**
+     * @see de.intevation.gnv.state.StateBase#setup(org.w3c.dom.Node)
+     */
+    @Override
+    public void setup(Node configuration) {
+        log.debug("OutputStateBase.setup");
+        super.setup(configuration);
+        
+        this.queryODVID = Config.getStringXPath(configuration,"queryID-odv");
+        
+        NodeList outputModeList = Config.getNodeSetXPath(configuration,
+                "outputsModes/outputsMode");
+        if (outputModeList != null) {
+            log.debug(outputModeList.getLength() + " were found.");
+            this.outputModes = new ArrayList<OutputMode>(outputModeList
+                    .getLength());
+            for (int i = 0; i < outputModeList.getLength(); i++) {
+                Element currentNode = (Element)outputModeList.item(i);
+                String name = currentNode.getAttribute("name");
+                String description =currentNode.getAttribute("description");
+                String mimeType = currentNode.getAttribute("mime-type");
+                NodeList inputValuesList = Config.getNodeSetXPath(currentNode,
+                        "parameters/inputvalue");
+                Collection<InputValue> inputParameters = null;
+                if (inputValuesList != null) {
+                    inputParameters = new ArrayList<InputValue>(inputValuesList
+                            .getLength());
+                    for (int j = 0; j < inputValuesList.getLength(); j++) {
+                        Element currentInputValuesNode = (Element)inputValuesList.item(j);
+                        String inputValueName = currentInputValuesNode.getAttribute("name");
+                        String inputValueType = currentInputValuesNode.getAttribute("type");
+                        String defaultValue =currentInputValuesNode.getAttribute("value");
+                        boolean isMultiselect = false;
+                        InputValue inputValue = new DefaultInputValue(
+                                inputValueName, inputValueType, defaultValue,
+                                isMultiselect);
+                        inputParameters.add(inputValue);
+                    }
+                }
+
+                // parse export modes
+                List<ExportMode> exportList = null;
+                NodeList exports = (NodeList) XMLUtils.xpath(
+                    currentNode, XPATH_EXPORTS, XPathConstants.NODESET);
+
+                if (exports != null) {
+                    int exportSize   = exports.getLength();
+
+                    exportList = new ArrayList<ExportMode>(exportSize);
+                    for (int k = 0; k < exportSize; k++) {
+                        Element exp    = (Element) exports.item(k);
+                        String expName = exp.getAttribute("name");
+                        String expDesc = exp.getAttribute("description");
+                        String expMime = exp.getAttribute("mime-type");
+
+                        exportList.add(
+                            new DefaultExportMode(expName, expDesc, expMime));
+                    }
+                }
+
+                OutputMode outputMode = new DefaultOutputMode(name,
+                        description, mimeType, inputParameters, exportList);
+                log.debug(outputMode.toString());
+                this.outputModes.add(outputMode);
+
+            }
+        }
+    }
+
+    /**
+     * @see de.intevation.gnv.state.StateBase#advance()
+     */
+    @Override
+    public void advance(String uuid, CallContext context)
+    throws StateException
+    {
+    }
+
+    @Override
+    public void initialize(String uuid, CallContext context)
+    throws StateException
+    {
+    }
+
+    public void out(
+        Document              format, 
+        Collection<InputData> inputData,
+        OutputStream          outputStream, 
+        String                uuid, 
+        CallMeta              callMeta
+    )
+    throws StateException 
+    {
+    }
+
+    /**
+     * @see de.intevation.gnv.state.OutputState#out(java.lang.String,
+     *      java.util.Collection, java.io.OutputStream)
+     */
+    public void out(String outputMode, Collection<InputData> inputData,
+                    OutputStream outputStream) throws StateException {
+    }
+
+    /**
+     * @return
+     */
+    protected Object getChartResult(String uuid, CallContext callContext) {
+        log.debug("OutputStateBase.getChartResult");
+        CacheFactory factory = CacheFactory.getInstance();
+
+        if (factory.isInitialized()) {
+            // we use a cache
+            log.info("Using cache.");
+            Cache cache = factory.getCache();
+            String key  = "chart_" + getHash();
+
+            net.sf.ehcache.Element value = cache.get(key);
+            if (value != null) {
+                log.debug("Found element in cache.");
+                return value.getObjectValue();
+            }
+            else {
+                log.debug("Element not in cache, we need to ask the database");
+                Object result = getData(queryID);
+                cache.put(new net.sf.ehcache.Element(key, result));
+
+                return result;
+            }
+        }
+        else {
+            // we don't use a cache, so we have to query the database every
+            // single time
+            log.info("Not using a cache.");
+            return getData(queryID);
+        }
+    }
+
+    protected Object getChartFromCache(String uuid, CallContext callContext) {
+        log.debug("Fetch chart [" + uuid + "] from cache");
+        CacheFactory cacheFactory = CacheFactory.getInstance();
+        if (cacheFactory.isInitialized()) {
+            String key = "chart_" + getHash();
+            net.sf.ehcache.Element object = cacheFactory.getCache().get(key);
+
+            if (object != null) {
+                return object.getObjectValue();
+            }
+        }
+        return null;
+    }
+    
+    protected Collection<Result> getODVResult(String uuid) {
+        log.debug("OutputStateBase.getODVResult");
+        // TODO add Caching? I think it's not nessessary
+        Collection<Result> returnValue = null;
+        if (this.queryODVID != null){
+            returnValue = this.getData(this.queryODVID);
+        }else{
+            log.warn("No Query for ODV Data is defined.");
+        }
+        return returnValue;
+    }
+
+    /**
+     * @param returnValue
+     * @return
+     */
+    protected Collection<Result> getData(String queryID) {
+        log.debug("OutputStateBase.getData");
+        Collection<Result> returnValue = null;
+        try {
+            String[] filterValues = this.generateFilterValuesFromInputData();
+            try {
+                QueryExecutor queryExecutor = QueryExecutorFactory
+                                              .getInstance()
+                                              .getQueryExecutor();
+                returnValue  = queryExecutor.executeQuery(queryID,filterValues);
+            } catch (RuntimeException e) {
+                log.error(e, e);
+            }
+        } catch (QueryException e) {
+            log.error(e, e);
+        }
+        return returnValue;
+    }
+    
+    protected void removeChartResult(String uuid) {
+        log.debug("OutputStateBase.getChartResult");
+        if (CacheFactory.getInstance().isInitialized()) {
+            String key = "chart_" + getHash();
+            log.debug("Hash for Queryelements: " + key);
+            net.sf.ehcache.Element value = CacheFactory.getInstance().getCache().get(key);
+            if (value != null) {
+                CacheFactory.getInstance().getCache().remove(key);
+            }
+        }
+    }
+
+    protected void removeChart(String uuid) {
+        log.debug("OutputStateBase.removeChart from cache");
+
+        CacheFactory cacheFactory = CacheFactory.getInstance();
+        if (cacheFactory.isInitialized()) {
+            String key = "chart_" + getHash();
+            net.sf.ehcache.Element object = cacheFactory.getCache().get(key);
+            if (object != null)
+                cacheFactory.getCache().remove(key);
+        }
+    }
+
+    protected void purifyChart(Object chart, String uuid) {
+        log.debug("Prufify chart [" + uuid + "]");
+        CacheFactory cacheFactory = CacheFactory.getInstance();
+        if (cacheFactory.isInitialized()) {
+            String key = "chart_" + getHash();
+            cacheFactory.getCache().put(new net.sf.ehcache.Element(key, chart));
+        }
+    }
+
+
+    @Override
+    public void feed(Collection<InputData> inputData, String uuid)
+    throws StateException
+    {
+        putInputData(inputData, uuid);
+    }
+
+    /**
+     * @see de.intevation.gnv.state.StateBase#putInputData(java.util.Collection, java.lang.String)
+     */
+    @Override
+    public void putInputData(Collection<InputData> inputData, 
+                             String uuid)
+                                         throws StateException {
+        log.debug("OutputStateBase.putInputData");
+        this.removeChartResult(uuid);
+        this.removeChart(uuid);
+
+        if (inputData != null) {
+            Iterator<InputData> it = inputData.iterator();
+            InputValidator iv = new InputValidator();
+            while (it.hasNext()) {
+                InputData tmpItem     = it.next();
+                Object    tmpObj      = tmpItem.getObject();
+                InputValue inputValue = this.inputValues.get(tmpItem.getName());
+                if (inputValue != null) {
+                    if (this.inputData == null) {
+                        this.inputData = new HashMap<String, InputData>(
+                                inputData.size());
+                    }
+
+                    boolean valid = iv.isInputValid(tmpItem.getValue(),
+                            inputValue.getType());
+                    if (valid) {
+                        if (tmpItem.getName().equals(MINVALUEFIELDNAME)){
+                            String minValue = tmpItem.getValue();
+                            String maxValue = getInputValue4ID(inputData, MAXVALUEFIELDNAME);
+                            valid = iv.isInputValid(maxValue,inputValue.getType());
+                            if (!valid){
+                                String errMsg = "Wrong input for " + tmpItem.getValue()
+                                                + " is not an " + inputValue.getType()
+                                                + " Value.";
+                                log.warn(errMsg);
+                                throw new StateException(errMsg);
+                            }
+
+                            valid = iv.isInputValid(minValue,
+                                    maxValue,
+                                    inputValue.getType());
+                            if (!valid){
+                                String errMsg = "MaxValue-Input is less than MinValue-Input ";
+                                log.warn(errMsg);
+                                throw new StateException(errMsg);
+                            }
+                        }else if (tmpItem.getName().equals(MAXVALUEFIELDNAME)){
+                            String minValue = getInputValue4ID(inputData, MINVALUEFIELDNAME);
+                            String maxValue = tmpItem.getValue();
+                            valid = iv.isInputValid(minValue,inputValue.getType());
+                            if (!valid){
+                                String errMsg = "Wrong input for " + tmpItem.getValue()
+                                                + " is not an " + inputValue.getType()
+                                                + " Value.";
+                                log.warn(errMsg);
+                                throw new StateException(errMsg);
+                            }
+
+                            valid = iv.isInputValid(minValue,
+                                                    maxValue,
+                                                    inputValue.getType());
+                            if (!valid){
+                                String errMsg = "MaxValue-Input is less than MinValue-Input ";
+                                log.warn(errMsg);
+                                throw new StateException(errMsg);
+                            }
+                        }
+                        this.inputData.put(tmpItem.getName(), tmpItem);
+                    } else {
+                        String errMsg = "Wrong input for " + tmpItem.getValue()
+                                        + " is not an " + inputValue.getType()
+                                        + " Value.";
+                        log.warn(errMsg);
+                        throw new StateException(errMsg);
+                    }
+
+                } 
+                else if (tmpObj != null && tmpObj instanceof MinMaxDescribeData) {
+                    MinMaxDescribeData data = (MinMaxDescribeData) tmpObj;
+                    if (this.inputData == null) {
+                        this.inputData = new HashMap<String, InputData>(inputData.size());
+                    }
+                    this.inputData.put(tmpItem.getName(), tmpItem);
+                    this.inputData.put("minvalue", new DefaultInputData("minvalue", (String) data.getMinValue()));
+                    this.inputData.put("maxvalue", new DefaultInputData("maxvalue", (String) data.getMaxValue()));
+                }
+                else {
+                
+                    String errMsg = "No Inputvalue given for Inputdata "
+                                    + tmpItem.getName();
+                    log.warn(errMsg + "Value will be ignored");
+
+                }
+            }
+        } else {
+            log.warn("No Inputdata given");
+        }
+    }
+
+    public void out(String outputMode, Collection<InputData> inputData,
+                    OutputStream outputStream, String uuid, CallMeta callMeta)
+                                                                              throws StateException {
+    }
+
+
+    protected String getMessage(Locale locale, String key, String value) {
+        return RessourceFactory.getInstance().getRessource(
+            locale,
+            key,
+            value
+        );
+    }
+}
+// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8: