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

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

    /** if this is set to true, when a document is displayed, any annotation
     * type services (enrich) will be offered to the user as well */
    protected static final boolean provide_annotations = false; //true;

    public Element process (Element message)
    {
    // for now, no subaction eventually we may want to have subactions such as text assoc or something ?
    
    // the response
    Element result = doc_.createElement(GSXML.MESSAGE_ELEM);
    Element page_response = doc_.createElement(GSXML.RESPONSE_ELEM);
    result.appendChild(page_response);

    // 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 lang = request.getAttribute(GSXML.LANG_ATT);
    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 result;
    }

    //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;
    }
    
    // get the additional data needed for the page
    getBackgroundData(page_response, collection, lang);

    // the_document is where all the doc info - structure and metadata etc
    // is added into, to be returned in the page
    Element the_document = doc_.createElement(GSXML.DOCUMENT_ELEM);
    page_response.appendChild(the_document);

    
    // Build a request to obtain the document structure
    Element ds_message = doc_.createElement(GSXML.MESSAGE_ELEM);
    String to = GSPath.appendLink(collection, "DocumentStructureRetrieve");  // Hard-wired?
    Element ds_request = GSXML.createBasicRequest(doc_,GSXML.REQUEST_TYPE_PROCESS, to, lang); 
    ds_message.appendChild(ds_request);

    // 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");
    }

    // put these in for now, but we should really decide what to do on basis of type, eg get structure for toc, get info for paged navigation etc
    
    // add in the info params to test them
    ds_param = doc_.createElement(GSXML.PARAM_ELEM);
    ds_param_list.appendChild(ds_param);
    ds_param.setAttribute(GSXML.NAME_ATT, "info");
    ds_param.setAttribute(GSXML.VALUE_ATT, "numSiblings");
    ds_param = doc_.createElement(GSXML.PARAM_ELEM);
    ds_param_list.appendChild(ds_param);
    ds_param.setAttribute(GSXML.NAME_ATT, "info");
    ds_param.setAttribute(GSXML.VALUE_ATT, "numChildren");
    ds_param = doc_.createElement(GSXML.PARAM_ELEM);
    ds_param_list.appendChild(ds_param);
    ds_param.setAttribute(GSXML.NAME_ATT, "info");
    ds_param.setAttribute(GSXML.VALUE_ATT, "siblingPosition");
    
    // 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.NODE_ID_ATT, document_name);
    
    // Process the document structure retrieve message
    Element ds_response_message = (Element) mr_.process(ds_message);

    // get the info and print out
    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, "nodeStructureInfo");
    Element ds_response_struct_info = (Element) GSXML.getNodeByPath(ds_response_message, path);
    // get the doc_node bit 
    the_document.appendChild(doc_.importNode(ds_response_struct_info, true)); 
    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.NODE_STRUCTURE_ELEM);
    Element ds_response_structure = (Element) GSXML.getNodeByPath(ds_response_message, path);

    // 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);
    to = GSPath.appendLink(collection, "DocumentMetadataRetrieve");  // Hard-wired?
    Element dm_request = GSXML.createBasicRequest(doc_, GSXML.REQUEST_TYPE_PROCESS, to, lang);
    dm_message.appendChild(dm_request);
    // 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.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.NODE_ID_ATT, doc_node_id);
        dm_doc_node.setAttribute(GSXML.NODE_TYPE_ATT,
                     doc_node.getAttribute(GSXML.NODE_TYPE_ATT));
    }

    // we also want a metadata request to the top level document to get
    // assocfilepath - this could be cached too
    Element doc_meta_request = GSXML.createBasicRequest(doc_, GSXML.REQUEST_TYPE_PROCESS, to, lang);
    dm_message.appendChild(doc_meta_request);
    Element doc_meta_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    doc_meta_request.appendChild(doc_meta_param_list);
    Element doc_param = doc_.createElement(GSXML.PARAM_ELEM);
    doc_meta_param_list.appendChild(doc_param);
    doc_param.setAttribute(GSXML.NAME_ATT, "metadata");
    doc_param.setAttribute(GSXML.VALUE_ATT, "assocfilepath");

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

    Element doc_node = doc_.createElement(GSXML.DOC_NODE_ELEM);
    // teh node we want is the root document node
    doc_node.setAttribute(GSXML.NODE_ID_ATT, document_name+".rt");
    doc_list.appendChild(doc_node);
    Element dm_response_message = (Element) mr_.process(dm_message);

    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));
    }
    // get teh top level do metadata out
    Element doc_meta_response = (Element)dm_response_message.getElementsByTagName(GSXML.RESPONSE_ELEM).item(1);
    Element doc_meta_list = (Element)GSXML.getNodeByPath(doc_meta_response, "documentNodeList/documentNode/metadataList");
    the_document.appendChild(doc_.importNode(doc_meta_list, true));

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

    // 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);

    Element dc_response_message = (Element) mr_.process(dc_message);
    
    path = GSPath.appendLink(path, GSXML.DOC_NODE_ELEM);
    Element dc_response_doc = (Element) GSXML.getNodeByPath(dc_response_message, path);
    Element dc_response_doc_content = (Element) GSXML.getChildByTagName(dc_response_doc, GSXML.NODE_CONTENT_ELEM);
    if (provide_annotations) {
        // now we can modifiy the response doc if needed
        String enrich_service = (String)params.get(GSCGI.SERVICE_ARG);
        if (enrich_service != null && !enrich_service.equals("")) {
        // send a message to the service
        Element enrich_message = doc_.createElement(GSXML.MESSAGE_ELEM);
        Element enrich_request = GSXML.createBasicRequest(doc_, GSXML.REQUEST_TYPE_PROCESS, enrich_service, lang);
        enrich_message.appendChild(enrich_request);
        Element enrich_pl = getServiceParamList(cgi_paramList);
        enrich_request.appendChild(enrich_pl);
        Element e_doc_list = doc_.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
        enrich_request.appendChild(e_doc_list);
        e_doc_list.appendChild(doc_.importNode(dc_response_doc, true));
        
        Element enrich_response = mr_.process(enrich_message);
        
        String [] links = {GSXML.RESPONSE_ELEM, GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER, GSXML.DOC_NODE_ELEM, GSXML.NODE_CONTENT_ELEM};
        path = GSPath.createPath(links);
        dc_response_doc_content = (Element)GSXML.getNodeByPath(enrich_response, path);
        } 
    }
    // 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);
    the_document.setAttribute("selectedNode", modified_doc_id);
    // Merge the document content with the metadata and structure information
    for (int i = 0; i < doc_nodes.getLength(); i++) {
        Node dn = doc_nodes.item(i);
        String dn_id = ((Element)dn).getAttribute(GSXML.NODE_ID_ATT);
        if (dn_id.equals(modified_doc_id)) {
        dn.appendChild(doc_.importNode(dc_response_doc_content, true));
        break;
        }
    }

    System.out.println("(DocumentAction) Page:\n" + converter_.getPrettyString(result));
    return result;
    }

    protected Element getServiceParamList(Element cgi_param_list) {

    Element new_param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    Element param;
    NodeList cgi_params = cgi_param_list.getChildNodes();
    for (int i=0; i<cgi_params.getLength(); i++) {
        Element p = (Element) cgi_params.item(i);
        String name = p.getAttribute(GSXML.NAME_ATT);
        if (name.equals(GSCGI.SERVICE_ARG) || name.equals(GSCGI.REQUEST_TYPE_ARG) || name.equals(GSCGI.CLUSTER_ARG) || name.equals(GSCGI.DOCUMENT_ARG) || name.equals(SIBLING_ARG) ) {
        continue;
        }
        // esle add it in to the list
        new_param_list.appendChild(doc_.importNode(p, true));
    }
    return new_param_list;
    }

    /** this method gets the collection description, the format info, the
     * list of enrich services, etc - stuff that is needed for the page,
     * but is the same whatever the query is - should be cached */
    protected  boolean getBackgroundData(Element page_response, 
                     String collection, String lang) {

    // create a message to process - contains requests for the collection 
    // description, the format element, the enrich services on offer
    // these could all be cached
    Element info_message = doc_.createElement(GSXML.MESSAGE_ELEM);

    // the format request - ignore for now, where does this request go to??
    //Element format_request = GSXML.createBasicRequest(doc_, GSXML.REQUEST_TYPE_FORMAT, ???, lang);
    //info_message.appendChild(format_request);

    // the enrich_services request - only do this if provide_annotations is true

    if (provide_annotations) {
        Element enrich_services_request = GSXML.createBasicRequest(doc_, GSXML.REQUEST_TYPE_DESCRIBE, "", lang);
        enrich_services_request.setAttribute(GSXML.INFO_ATT, "serviceList");
        info_message.appendChild(enrich_services_request);
    }
    
    Element info_response = (Element)mr_.process(info_message);

    // the collection is the first response
    NodeList responses = info_response.getElementsByTagName(GSXML.RESPONSE_ELEM);
    //Element format_resp = (Element) responses.item(1);
    //page_reponse.appendChild(doc_.importNode(GSXML.getChildByTagName(format_resp, GSXML.FORMAT_ELEM), true));
    

    if (provide_annotations) {
        Element services_resp = (Element)responses.item(0); // change when format request added in

        // a new message for the mr
        Element enrich_message = doc_.createElement(GSXML.MESSAGE_ELEM);
        
        NodeList e_services = services_resp.getElementsByTagName(GSXML.SERVICE_ELEM);
        boolean service_found = false;
        for (int j=0; j<e_services.getLength(); j++) {
        if (((Element)e_services.item(j)).getAttribute(GSXML.TYPE_ATT).equals("enrich")) {
            Element s = GSXML.createBasicRequest(doc_, GSXML.REQUEST_TYPE_DESCRIBE, ((Element)e_services.item(j)).getAttribute(GSXML.NAME_ATT), lang);
            enrich_message.appendChild(s);
            service_found = true;
        }
        }
        if (service_found) {
        Element enrich_response = mr_.process(enrich_message);

        NodeList e_responses = enrich_response.getElementsByTagName(GSXML.RESPONSE_ELEM);
        Element service_list = doc_.createElement(GSXML.SERVICE_ELEM + GSXML.LIST_MODIFIER);
        for (int i=0; i<e_responses.getLength(); i++) {
            Element e_resp = (Element)e_responses.item(i);
            Element e_service = (Element)doc_.importNode(GSXML.getChildByTagName(e_resp, GSXML.SERVICE_ELEM), true); 
            e_service.setAttribute(GSXML.NAME_ATT, e_resp.getAttribute(GSXML.FROM_ATT));
            service_list.appendChild(e_service);
        }
        page_response.appendChild(service_list);
        }
    } // if provide_annotations
    return true;
        
    }
}