source: trunk/gsdl3/src/java/org/greenstone/gsdl3/action/DocumentAction.java@ 3913

/*
 *    DocumentAction.java
 *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package org.greenstone.gsdl3.action;

// Greenstone classes
import org.greenstone.gsdl3.core.ModuleInterface;
import org.greenstone.gsdl3.util.*;

// XML classes
import org.w3c.dom.Document; 
import org.w3c.dom.Element; 
import org.w3c.dom.Node; 
import org.w3c.dom.NodeList;

// General Java classes
import java.util.HashMap;
import java.io.File;


/** Action class for retrieving Documents  via the message router
 */
public class DocumentAction extends Action {
  
    // this is used to specify that the sibling nodes of a selected one should be obtained
    public static final String SIBLING_ARG = "sib";

    /* add the action specific args to the cgi param list
     */
    public void addCGIParams() {
    cgi_.addStaticParam(SIBLING_ARG);
    }


    public Element process (Element message)
    {
    // for now, no subaction eventually we may want to have subactions such as text assoc or something ?
    
    // get the request - assume only one
    Element request = (Element)GSXML.getChildByTagName(message, GSXML.REQUEST_ELEM);
    Element cgi_paramList = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    HashMap params = GSXML.extractParams(cgi_paramList, false);

    String collection = (String) params.get(GSCGI.COLLECTION_ARG);
    String to;
    String document_name = (String) params.get(GSCGI.DOCUMENT_ARG);
    if (document_name == null || document_name.equals("")) {
        System.err.println("DocumentAction Error: no document specified!");
        return null;
    }
    //whether to retrieve siblings or not
    boolean get_siblings = false;
    String sibs = (String) params.get(SIBLING_ARG);
    if (sibs != null && sibs.equals("1")) {
        get_siblings = true;
    }
    
    // Build a request to obtain the document structure
    Element ds_message = doc_.createElement(GSXML.MESSAGE_ELEM);
    Element ds_request = doc_.createElement(GSXML.REQUEST_ELEM);
    ds_message.appendChild(ds_request);
    to = GSPath.appendLink(collection, "DocumentStructureRetrieve");  // Hard-wired?
    ds_request.setAttribute(GSXML.TO_ATT, to);
    ds_request.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
    ds_request.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT));

    // Create a parameter list to specify the required structure information
    Element ds_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    ds_request.appendChild(ds_param_list);
    Element ds_param = doc_.createElement(GSXML.PARAM_ELEM);
    ds_param_list.appendChild(ds_param);
    ds_param.setAttribute(GSXML.NAME_ATT, "structure");
    ds_param.setAttribute(GSXML.VALUE_ATT, "ancestors");
    ds_param = doc_.createElement(GSXML.PARAM_ELEM);
    ds_param_list.appendChild(ds_param);
    ds_param.setAttribute(GSXML.NAME_ATT, "structure");
    ds_param.setAttribute(GSXML.VALUE_ATT, "children");
    if (get_siblings) {
        ds_param = doc_.createElement(GSXML.PARAM_ELEM);
        ds_param_list.appendChild(ds_param);
        ds_param.setAttribute(GSXML.NAME_ATT, "structure");
        ds_param.setAttribute(GSXML.VALUE_ATT, "siblings");
    }
    // create a doc_node_list and put in the doc_node that we are interested in
    Element ds_doc_list = doc_.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    ds_request.appendChild(ds_doc_list);
    Element ds_doc = doc_.createElement(GSXML.DOC_NODE_ELEM);
    ds_doc_list.appendChild(ds_doc);
    ds_doc.setAttribute(GSXML.DOC_NODE_ID_ATT, document_name);
    
    // Process the document structure retrieve message
    // System.out.println("(DocumentAction) Structure request:\n" + converter_.getString(ds_message));
    Element ds_response_message = (Element) mr_.process(ds_message);
    // System.out.println("(DocumentAction) Structure response:\n" + converter_.getString(ds_response_message));

    // get the doc_node bit 
    String path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    path = GSPath.appendLink(path, GSXML.DOC_NODE_ELEM);
    path = GSPath.appendLink(path, GSXML.DOC_NODE_STRUCTURE_ELEM);
    Element ds_response_structure = (Element) GSXML.getNodeByPath(ds_response_message, path);

    // the_document is where all the extra info is added into, to be returned in the page
    Element the_document = doc_.createElement(GSXML.DOCUMENT_ELEM);
    // add the contents of the structure bit into the_document
    NodeList structs = ds_response_structure.getChildNodes();
    for (int i=0; i<structs.getLength();i++) {
        the_document.appendChild(doc_.importNode(structs.item(i), true));
    }

    // Build a request to obtain some document metadata
    Element dm_message = doc_.createElement(GSXML.MESSAGE_ELEM);
    Element dm_request = doc_.createElement(GSXML.REQUEST_ELEM);
    dm_message.appendChild(dm_request);
    to = GSPath.appendLink(collection, "DocumentMetadataRetrieve");  // Hard-wired?
    dm_request.setAttribute(GSXML.TO_ATT, to);
    dm_request.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
    dm_request.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT));

    // Create a parameter list to specify the required metadata information
    // for now get Title
    Element dm_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    dm_request.appendChild(dm_param_list);
    Element dm_param = doc_.createElement(GSXML.PARAM_ELEM);
    dm_param_list.appendChild(dm_param);
    dm_param.setAttribute(GSXML.NAME_ATT, "metadata");
    dm_param.setAttribute(GSXML.VALUE_ATT, "Title");

    // create the doc node list for the metadata request
    Element dm_doc_list = doc_.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    dm_request.appendChild(dm_doc_list);

    // Add each node from the structure response into the metadata request
    NodeList doc_nodes = the_document.getElementsByTagName(GSXML.DOC_NODE_ELEM);
    for (int i = 0; i < doc_nodes.getLength(); i++) {
        Element doc_node = (Element) doc_nodes.item(i);
        String doc_node_id = doc_node.getAttribute(GSXML.DOC_NODE_ID_ATT);

        // Add the documentNode to the list
        Element dm_doc_node = doc_.createElement(GSXML.DOC_NODE_ELEM);
        dm_doc_list.appendChild(dm_doc_node);
        dm_doc_node.setAttribute(GSXML.DOC_NODE_ID_ATT, doc_node_id);
        dm_doc_node.setAttribute(GSXML.DOC_NODE_TYPE_ATT,
                     doc_node.getAttribute(GSXML.DOC_NODE_TYPE_ATT));
    }

    // System.out.println("(DocumentAction) Metadata request:\n" + converter_.getString(dm_request));
    Element dm_response_message = (Element) mr_.process(dm_message);
    // System.out.println("(DocumentAction) Metadata response:\n" + converter_.getString(dm_response));

    path = GSPath.appendLink(GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    Element dm_response_doc_list = (Element) GSXML.getNodeByPath(dm_response_message, path);

    // Merge the metadata with the structure information
    NodeList dm_response_docs = dm_response_doc_list.getChildNodes();
    for (int i = 0; i < doc_nodes.getLength(); i++) {
        GSXML.mergeMetadataLists(doc_nodes.item(i), dm_response_docs.item(i));
    }


    // Build a request to obtain some document content
    Element dc_message = doc_.createElement(GSXML.MESSAGE_ELEM);
    Element dc_request = doc_.createElement(GSXML.REQUEST_ELEM);
    dc_message.appendChild(dc_request);
    to = GSPath.appendLink(collection, "DocumentContentRetrieve");  // Hard-wired?
    dc_request.setAttribute(GSXML.TO_ATT, to);
    dc_request.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);
    dc_request.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT));

    // Create a parameter list to specify the request parameters - empty for now
    Element dc_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    dc_request.appendChild(dc_param_list);

    // the doc list for the content request is the same as the one for the structure request
    dc_request.appendChild(ds_doc_list);

    // System.out.println("(DocumentAction) Content request:\n" + converter_.getString(dc_request));
    Element dc_response_message = (Element) mr_.process(dc_message);
    // System.out.println("(DocumentAction) Content response:\n" + converter_.getString(dc_response));
    
    path = GSPath.appendLink(path, GSXML.DOC_NODE_ELEM);
    Element dc_response_doc = (Element) GSXML.getNodeByPath(dc_response_message, path);
    //path = GSPath.appendLink(path, GSXML.DOC_NODE_CONTENT_ELEM);
    Element dc_response_doc_content = (Element) GSXML.getChildByTagName(dc_response_doc, GSXML.DOC_NODE_CONTENT_ELEM);
    // use the returned id rather than the sent one cos there may have
    // been modifiers such as .pr that are removed.
    String modified_doc_id = dc_response_doc.getAttribute(GSXML.NODE_ID_ATT);
    // Merge the document content with the metadata and structure information
    for (int i = 0; i < doc_nodes.getLength(); i++) {
        Node doc_node = doc_nodes.item(i);
        Node doc_node_id = doc_node.getAttributes().getNamedItem(GSXML.DOC_NODE_ID_ATT);
        String dc_doc_id = doc_node_id.getNodeValue();
        if (dc_doc_id.equals(modified_doc_id)) {
        doc_node.appendChild(doc_.importNode(dc_response_doc_content, true));
        break;
        }
    }

    // Create the return page tree
    Element page = doc_.createElement(GSXML.PAGE_ELEM);
    page.setAttribute(GSXML.LANG_ATT, request.getAttribute(GSXML.LANG_ATT));

    // Add the display element, config stuff, and original request from the message
    page.appendChild(doc_.importNode(GSXML.getChildByTagName(message, GSXML.DISPLAY_ELEM), true));
    page.appendChild(doc_.importNode(GSXML.getChildByTagName(message, GSXML.CONFIGURATION_ELEM), true));
    page.appendChild(doc_.importNode(request, true));

    // Add the results of the action to the page
    Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
    page.appendChild(response);
    response.appendChild(the_document);
    
     System.out.println("doc action: Finished page: " + converter_.getString(page));
    
    
    // Finally, process using the stylesheet, and return
    String stylesheet = GSFile.stylesheetFile(config_, "document.xsl");
    if (stylesheet == null) {
        System.err.println("DocumentAction Error: document stylesheet not found!");
        return null;
    }

    Document style_doc = converter_.getDOM(new File(stylesheet));
    GSXSLT.absoluteIncludePaths(style_doc, config_);
    return (Element) transformer_.transform(style_doc, page);    
    }
}