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

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;

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

    /** the 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;

    /** the message router that the Receptionist and Actions will talk to */
    protected ModuleInterface mr=null;

    /** the list of actions */
    protected HashMap action_map=null;
    
    public Receptionist() {
    this.converter = new XMLConverter();
    this.doc = this.converter.newDOM();
    this.action_map= new HashMap();
    }
    
    public void setConfigParams(HashMap params) {
    this.config_params = params;
    }
    /** sets the message router  - it should already be created and 
     * configured before  being passed to the receptionist*/
    public void setMessageRouter(ModuleInterface m) {
       this.mr = m;
    }

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

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

    // find the config file containing a list of actions
    File interface_config_file = new File(GSFile.interfaceConfigFile(GSFile.interfaceHome((String)this.config_params.get(GSConstants.GSDL3_HOME), (String)this.config_params.get(GSConstants.INTERFACE_NAME))));
    if (!interface_config_file.exists()) {
        System.err.println("Receptionist: interface config file: "+interface_config_file.getPath()+" not found!");
        return false;
    }
    
    Element config_doc = this.converter.getDOM(interface_config_file).getDocumentElement();
    Element action_list = (Element)GSXML.getChildByTagName(config_doc, GSXML.ACTION_ELEM+GSXML.LIST_MODIFIER);
    NodeList actions = action_list.getElementsByTagName(GSXML.ACTION_ELEM);

    for (int i=0; i<actions.getLength(); i++) {
        Element action = (Element) actions.item(i);
        String class_name = action.getAttribute("class");
        String action_name = action.getAttribute("name");
        Action ac = null;
        try {
        ac = (Action)Class.forName("org.greenstone.gsdl3.action."+class_name).newInstance();
        } catch (Exception e) {
        System.out.println("couldn't load in action "+class_name);
        e.printStackTrace();
        continue;
        }
        ac.setConfigParams(this.config_params);
        ac.setMessageRouter(this.mr);
        ac.configure();
        this.action_map.put(action_name, ac);
    }

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

    Element message = this.converter.getDOM(xml_in).getDocumentElement();
    Element page = process(message);
    return this.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 the request type 
    String type = request.getAttribute(GSXML.TYPE_ATT); // returns "" if no att of this name
    if (!type.equals(GSXML.REQUEST_TYPE_PAGE)) { 
        // now Receptionist forwards non-page requests straight to the MR, and returns the responses
        System.err.println("Receptionist: request type is not '"+GSXML.REQUEST_TYPE_PAGE+"', but it is '"+type+"', so forwarding the message to the MR!");
        // process the whole message - mr needs <message> tags, and 
        // in this case, there may be more than one request in the message
        return this.mr.process(message);
    }   
    // 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;
    }
    
    // find the  appropriate action 
    Action a = (Action)this.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.setConfigParams(this.config_params);
        ac.setMessageRouter(this.mr);
        ac.configure();
        this.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;
        }
    }

    // transform the request in some way
    preProcessRequest(request);
    // set up the page
    Element page = this.doc.createElement(GSXML.PAGE_ELEM);
    page.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT));
    
    // get the page data from the action
    Element action_response = a.process(message);

    boolean response_only=false;
    Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    if (param_list != null) {
        Element param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, "ro");
        if (param != null) {
        String value = param.getAttribute("value");
        if (value.equals("1")) {
            response_only = true;
        }
        }
    }
    if (response_only) {
        // only the response from the action is sent back
        return action_response;
    }
    
    // the request is part of the page
    page.appendChild(GSXML.duplicateWithNewName(this.doc, request, GSXML.PAGE_REQUEST_ELEM, true));
    // add the response too
    Element page_response = GSXML.duplicateWithNewName(this.doc, (Element)GSXML.getChildByTagName(action_response, GSXML.RESPONSE_ELEM), GSXML.PAGE_RESPONSE_ELEM, true);
    page.appendChild(page_response);

    // transform the result in some way
    Element resulting_page = postProcessPage(page);
    return resulting_page;
    
    }

    protected void preProcessRequest(Element request) {
    return;
    }

    protected Element postProcessPage(Element page) {
    return page;
    }
    

}