source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/action/Action.java@ 24219

package org.greenstone.gsdl3.action;

import org.greenstone.gsdl3.core.ModuleInterface;
import org.greenstone.gsdl3.util.*;
// XML classes
import org.w3c.dom.Node; 
import org.w3c.dom.NodeList; 
import org.w3c.dom.Element; 
import org.w3c.dom.Document; 

// other java stuff
import java.io.File;
import java.util.Vector;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;

import org.apache.log4j.*;

/** base class for Actions */
abstract public class Action {

    /** the system set up variables */
    protected HashMap config_params = null;
    /** container Document to create XML Nodes */
    protected Document doc=null; 
    /** a converter class to parse XML and create Docs */
    protected XMLConverter converter=null;
    /** a reference to the message router that it must talk to to
     * get info. it may be a communicator acting as a proxy, but it 
     doesn't care about that */
    protected ModuleInterface mr=null;

    static Logger logger = Logger.getLogger(org.greenstone.gsdl3.action.Action.class.getName());

    public Action() {
        this.converter = new XMLConverter();
        this.doc = this.converter.newDOM();
    }

    /** the config variables must be set before configure is called */
    public void setConfigParams(HashMap params) {
        this.config_params = params;
    }
    /** sets the message router */
    public void setMessageRouter(ModuleInterface m) {
        this.mr = m;
    }
    public boolean configure() {
        // does nothing yet
        return true;
    }
    
    /** process takes an xml representation of cgi args
     * and returns the page of results - may be in html/xml/other
     * depending on the output att of the request */
    public String process(String xml_in) {
       
        Document message_doc = this.converter.getDOM(xml_in);
        if (message_doc == null) {
            logger.error("Couldn't parse request");
            logger.error(xml_in);
            return null;
       }
       Node result = process(message_doc);
       return this.converter.getString(result);
    }
    
    /** the main process method - must be implemented in subclass */
    abstract public Node process(Node xml_in);

    /** tell the param class what its arguments are 
     * if an action has its own arguments, this should add them to the params
     * object - particularly important for args that should not be saved */
    public boolean getActionParameters(GSParams params) {
        return true;
    }

    protected void extractMetadataNames(Element format, HashSet meta_names) {
    //NodeList nodes = format.getElementsByTagNameNS("metadata", "http://www.greenstone.org/configformat");
    NodeList metadata_nodes = format.getElementsByTagName("gsf:metadata");
        for (int i=0; i<metadata_nodes.getLength(); i++) {
            Element elem = (Element)metadata_nodes.item(i);
            StringBuffer metadata = new StringBuffer();
            String all = elem.getAttribute("multiple");
            String name = elem.getAttribute("name");
            String select = elem.getAttribute("select");
            String sep = elem.getAttribute("separator");
            if (all.equals("true")) {
                metadata.append("all");
                metadata.append(GSConstants.META_RELATION_SEP);
            }
            if (!select.equals("")) {
                metadata.append(select);
                metadata.append(GSConstants.META_RELATION_SEP);
            }
            if (!sep.equals("")) {
                metadata.append(GSConstants.META_SEPARATOR_SEP);
                metadata.append(sep);
                metadata.append(GSConstants.META_SEPARATOR_SEP);
                metadata.append(GSConstants.META_RELATION_SEP);
            }

            metadata.append(name);
            meta_names.add(metadata.toString());
        }
    
    // The XSL tranform for
    //   gsf:link type="source" 
    // makes use of 'assocfilepath' so need to make sure it's asked for
    
    NodeList link_nodes = format.getElementsByTagName("gsf:link");
    for (int i=0; i<link_nodes.getLength(); i++) {
        Element elem = (Element)link_nodes.item(i);
        String type = elem.getAttribute("type");
        if (type.equals("source")) {
        meta_names.add("assocfilepath");
        } else if (type.equals("sourcelinkfile")) {
        meta_names.add("assocfilepath");
        //meta_names.add("srclinkFile");
        }
    }


    // get all the metadata necessary for when the user has used "gsf:equivlink"
    // so that we can build up the equivlink from the metadata components it needs
    link_nodes = format.getElementsByTagName("gsf:equivlinkgs3"); 
    if(link_nodes != null) {      

        String[] equivlink_metanames = {"equivDocIcon", "equivDocLink", "/equivDocLink"};

        for(int i = 0; i < equivlink_metanames.length; i++) {
        StringBuffer metadata = new StringBuffer();
        metadata.append("all"); // this means the attr multiple = true;
        metadata.append(GSConstants.META_RELATION_SEP);
        
        metadata.append(GSConstants.META_SEPARATOR_SEP);
        metadata.append(','); // attr separator = ","
        metadata.append(GSConstants.META_SEPARATOR_SEP);
        metadata.append(GSConstants.META_RELATION_SEP);
        
        // the name of the metadata we're retrieving
        metadata.append(equivlink_metanames[i]);
        meta_names.add(metadata.toString());
        }
    }
    }

    protected Element createMetadataParamList(HashSet metadata_names) {
        Element param_list  = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
        
        Element param = null;
        Iterator i = metadata_names.iterator();
        while (i.hasNext()) {
            String name = (String)i.next();
            param = this.doc.createElement(GSXML.PARAM_ELEM);
            param_list.appendChild(param);
            param.setAttribute(GSXML.NAME_ATT, "metadata");
            param.setAttribute(GSXML.VALUE_ATT, name);
        
        }
        return param_list;
    }

    protected boolean processErrorElements(Element message, Element page) {
        NodeList error_nodes = message.getElementsByTagName(GSXML.ERROR_ELEM);
        if (error_nodes.getLength()==0) {
            return false;
        }
        Document owner = page.getOwnerDocument();
        for (int i=0; i<error_nodes.getLength(); i++) {
            page.appendChild(owner.importNode(error_nodes.item(i), true));
        }
        return true;
    }

    /**
     * Takes an XML element and adds the metadata of the current site to it.
     * Useful for adding the current site's metadata to a response before sending it
     *
     * @param  element   the element to add site metadata to
     * @param  lang      the current language
     * @param  uid       the current user id
     */
    protected void addSiteMetadata( Element element, String lang, String uid ) {
        //ADD SITE METADATA
        Element metadata_request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, "", lang, uid);
        //create a hashmap of params
        HashMap subset_params = new HashMap(1);
        subset_params.put(GSXML.SUBSET_PARAM, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
        //create the element to put the params in
        Element param_list = this.doc.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
        //put them in
        GSXML.addParametersToList( this.doc, param_list, subset_params );
        metadata_request.appendChild(param_list);
        //create the message
        Element metadata_message = this.doc.createElement(GSXML.MESSAGE_ELEM);
        metadata_message.appendChild(metadata_request);
        //get response
        Element metadata_response_message = (Element)this.mr.process(metadata_message);
        //drill down to response
        Element metadata_response = (Element)GSXML.getChildByTagName(metadata_response_message, GSXML.RESPONSE_ELEM);
        //merge in metadata
        GSXML.mergeMetadataLists(element,metadata_response);
    }

}