source: trunk/gsdl3/src/java/org/greenstone/gsdl3/core/Receptionist.java@ 3644

package org.greenstone.gsdl3.core;

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

// other java classes
import java.io.File;
import java.util.HashMap;
import java.util.Enumeration;

/** core class for web interface generation. Receives requests consisting
 * of an xml representation of cgi args, and returns the page of data - in 
 * html by default. The requests are processed by the appropriate action class
 *
 * @see Action
 */
public class Receptionist implements ModuleInterface {

    /** the set up variables */
    protected ConfigVars config_=null;

    /** the cgi args converter */
    protected GSCGI cgi_ = null;

    /** container Document to create XML Nodes */
    protected Document doc_=null; 
   
    /** a converter class to parse XML and create Docs */
    protected XMLConverter converter_=null;

    /** the message router that the actions will talk to */
    protected ModuleInterface mr_=null;

    /** the list of actions */
    protected HashMap action_map_=null;

    public Receptionist() {
    converter_ = new XMLConverter();
    doc_ = converter_.newDOM();
    action_map_= new HashMap();
    cgi_ = new GSCGI();
    }
 
    /** the set up vars must be set before configure called*/
    public void setConfigVars(ConfigVars config) {
    config_ = config;
    }

    /** sets the message router  - it should already be created and 
     * configured before  being passed to the receptionist*/
    public void setMessageRouter(ModuleInterface m) {
       mr_ = m;
    }

    /** configures the receptionist */
    public boolean configure() {

    if (config_==null) {
        System.err.println("Receptionist Error: config variables must be set before calling configure");
        return false;
    }
    if (mr_==null) {       
        System.err.println("Receptionist Error: message router must be set  before calling configure");
        return false;
    }

    // add in the default actions - others can be dynamically 
    // loaded as needed
    // if you want an action to have a short name it needs to go here
    Action a = new PageAction();
    a.setConfigVars(config_);
    a.setMessageRouter(mr_);
    a.setCGI(cgi_);
    a.configure();
    action_map_.put("p", a);

    a = new QueryAction();
    a.setConfigVars(config_);
    a.setCGI(cgi_);
    a.setMessageRouter(mr_);
    a.configure();
    action_map_.put("q", a);

    a = new BrowseAction();
    a.setConfigVars(config_);
    a.setCGI(cgi_);
    a.setMessageRouter(mr_);
    a.configure();
    action_map_.put("b", a);

    a = new DocumentAction();
    a.setConfigVars(config_);
    a.setCGI(cgi_);
    a.setMessageRouter(mr_);
    a.configure();
    action_map_.put("d", a);

    a = new AppletAction();
    a.setConfigVars(config_);
    a.setCGI(cgi_);
    a.setMessageRouter(mr_);
    a.configure();
    action_map_.put("a", a);
    
    a = new ProcessAction();
    a.setConfigVars(config_);
    a.setCGI(cgi_);
    a.setMessageRouter(mr_);
    a.configure();
    action_map_.put("pr", a);


    return true;
    }
    /** process using strings - just calls process using Elements */
    public String process(String xml_in) {

    Element message = converter_.getDOM(xml_in).getDocumentElement();
    Element page = process(message);
    return converter_.getString(page);
    }

    /** process - produce a page of data in response to a request 
     * if something goes wrong, it returns null - 
     * TODO:  return a suitable message to the user */
    public Element process(Element message) {

    // get the request out of the message - assume that there is only one
    Element request = (Element)GSXML.getChildByTagName(message, GSXML.REQUEST_ELEM);
    if (request == null) {
        System.err.println("Receptionist Error: message had no request!");
        return null; 
    }
    // check that the request type is correct
    String type = request.getAttribute(GSXML.TYPE_ATT); // returns "" if no att of this name
    if (!type.equals(GSXML.REQUEST_TYPE_CGI)) {
        System.err.println("Receptionist Error: request type should be '"+GSXML.REQUEST_TYPE_CGI+"', but it was '"+type+"'!");
        return null;
    }   
    // work out which action to pass to
    String action = request.getAttribute(GSXML.ACTION_ATT);
    if (action.equals("")) {
        System.err.println("Receptionist Error: no action specified in the request!");
        return null;
    }
    // convert cgi short names to long names in the param list
    Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    if (param_list!=null) {
        if (!cgi_.paramListToLongNames(param_list)) {
        System.err.println("Receptionist Error: couldn't convert short names to long names in the param list!");
        return null;
        }
    }
    
    // pass request to appropriate action   
    Action a = (Action)action_map_.get(action);
    String action_name=null;
    if (a==null) { // not in the map yet
        // try to load a new action
        try {
        action_name = action.substring(0,1).toUpperCase()+action.substring(1)+"Action";
        Action ac = (Action)Class.forName("org.greenstone.gsdl3.action."+action_name).newInstance();
        ac.setConfigVars(config_);
        ac.setMessageRouter(mr_);
        ac.setCGI(cgi_);
        ac.configure();
        action_map_.put(action, ac);
        a = ac;
        } catch (Exception e) {
        
        System.err.println("Receptionist Error: a new action ("+action_name+") was specified and it couldn't be created. Error message:"+e.getMessage());
        return null;
        }
    }

    // add in the  system stuff - display and config
    Document message_doc = message.getOwnerDocument();
    String lang = request.getAttribute(GSXML.LANG_ATT);
    Element display = getDisplayElement(lang);
    message.appendChild(message_doc.importNode(display, true));
    message.appendChild(message_doc.importNode(config_.config_xml_, true));

    Element page = a.process(message);
    return page;
    
    }

    /** returns an xml element containing all the text strings 
     * needed for an interface 
     * currently only uses the current interface - should add in 
     * needed ones from the default interface if current != default */
    protected Element getDisplayElement(String lang) {

    Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
    // looks for properties files based on interface name
    String resource_name = "interface_"+config_.interface_name_;

    Dictionary dict = new Dictionary(resource_name, lang);
    Enumeration enum = dict.getKeys();
    while (enum.hasMoreElements()) {
        String key = (String)enum.nextElement();
        String value = dict.get(key);
        Element e = GSXML.createTextElement(doc_, key, value);
        display.appendChild(e);
    }
    return display;
    }

}