source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/action/GeneralDocumentListAction.java@ 37516

package org.greenstone.gsdl3.action;

import java.io.File;
import java.io.Serializable;
import java.util.HashMap;
import java.util.HashSet;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Result;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.greenstone.gsdl3.util.GSFile;
import org.greenstone.gsdl3.util.GSParams;
import org.greenstone.gsdl3.util.GSPath;
import org.greenstone.gsdl3.util.GSXML;
import org.greenstone.gsdl3.util.UserContext;
import org.greenstone.gsdl3.util.XMLConverter;
import org.greenstone.util.GlobalProperties;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class GeneralDocumentListAction extends Action
{

  /** process a request */
  public Node process(Node message_node)
  {
    Element message = GSXML.nodeToElement(message_node);
    Document doc = message.getOwnerDocument();
        
    // the result
    Element result = doc.createElement(GSXML.MESSAGE_ELEM);
    Element page_response = doc.createElement(GSXML.RESPONSE_ELEM);
    result.appendChild(page_response);

    // assume only one request
    Element request = (Element) GSXML.getChildByTagName(message, GSXML.REQUEST_ELEM);
    logger.debug(" request=" + this.converter.getString(request));

    UserContext userContext = new UserContext(request);

    // get the param list
    Element cgi_param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
    HashMap<String, Serializable> params = GSXML.extractParams(cgi_param_list, false);


    String service_name = (String) params.get(GSParams.SERVICE);
    String cluster_name = (String) params.get(GSParams.CLUSTER);
    String response_only_p = (String) params.get(GSParams.RESPONSE_ONLY);
    boolean response_only = false;
    if (response_only_p != null)
    {
      response_only = (response_only_p.equals("1") ? true : false);
    }
    String request_type = (String) params.get(GSParams.REQUEST_TYPE);
    // what is carried out depends on the request_type
    // if rt=d, then a describe request is done,
    // is rt=r, a request and then a describe request is done

    // if ro=1, then this calls for a process only page - we do the request
    // (rt should be r) and just give the response straight back
    // without any page processing

    // where to send requests
    String to;
    if (cluster_name != null)
    {
      to = GSPath.appendLink(cluster_name, service_name);
    }
    else
    {
      to = service_name;
    }

    // request the service info for the selected service - should be cached
    Element description_elem = getServiceDescription(to, userContext);

    if (request_type.equals("d"))
    {

      // we only want to describe the service
      if (description_elem != null)
      {
        page_response.appendChild((Element) doc.importNode(description_elem, true));
      }
      addSiteMetadata(page_response, userContext);
      addInterfaceOptions(page_response);
      return result;
      // thats all. format info here??
    }
    
    //ok, so now we do the actual request
    Element mr_query_message = doc.createElement(GSXML.MESSAGE_ELEM);
    Element mr_query_request = GSXML.createBasicRequest(doc, GSXML.REQUEST_TYPE_PROCESS, to, userContext);
    
    mr_query_message.appendChild(mr_query_request);
    
    Element param_list = null;
    // add in the service params - except the ones only used by the action
    HashMap service_params = (HashMap) params.get(GSParams.SERVICE_PREFIX);
    if (service_params != null)
    {
      param_list = doc.createElement(GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
      GSXML.addParametersToList(param_list, service_params);
      mr_query_request.appendChild(param_list);
    }

    Element mr_query_response = (Element) this.mr.process(mr_query_message);
    Element result_response = (Element) GSXML.getChildByTagName(mr_query_response, GSXML.RESPONSE_ELEM);

    if (result_response == null) {
      // something went wrong
      logger.error("no result from sending request to "+to);
      return result;
    }

    // we need to get metadata for the documents
    HashSet<String> doc_meta_names = new HashSet<String>();
    // always want this one
    doc_meta_names.add("root_assocfilepath");
    // we use extraMetadataList, plus anything that shows up in the service's format statement
    //get the format info for the service
    Element format_elem = getFormatInfo(to, userContext);
    if (format_elem != null) {
      // set the format type - what would it be for this??
      //format_elem.setAttribute(GSXML.TYPE_ATT, "");
      // add to the response
      page_response.appendChild(doc.importNode(format_elem, true));
    }
    // ... and find any metadata names mentioned in the format, or in extraMetadata
    getRequiredMetadataNames(doc_meta_names, format_elem, request);

    // TODO, do we want docType and nodeType attributes for each doc Node??
    addMetadataToDocNodes(result_response, doc_meta_names);
    
    if (response_only)
    {
      // just send the reponse as is
      addSiteMetadata(result_response, userContext);
      addInterfaceOptions(result_response);
      return result_response;
    }
    
    // else append the contents of the response to the page 
    GSXML.copyAllChildren(page_response, result_response);
    
    // another part of the page is the service description
    if (description_elem != null)
    {
      page_response.appendChild((Element) doc.importNode(description_elem, true));
    }

    addSiteMetadata(page_response, userContext);
    addInterfaceOptions(page_response);

    return result;
  }
  
  protected void addMetadataToDocNodes(Element result_elem, HashSet<String> meta_names) {
    
    Document doc = XMLConverter.newDOM();
    Document result_doc = result_elem.getOwnerDocument();
    HashMap<String, Element>coll_requests_map = new HashMap<String, Element>();
    
    Element message = doc.createElement(GSXML.MESSAGE_ELEM);
    
    // the param list - will be the same for all collection requests
    Element dm_param_list = createMetadataParamList(doc,meta_names);
  
    NodeList doc_nodes = result_elem.getElementsByTagName(GSXML.DOC_NODE_ELEM);
    for (int i = 0; i < doc_nodes.getLength(); i++) {
      Element dn = (Element) doc_nodes.item(i);
      String collection = dn.getAttribute(GSXML.COLLECTION_ATT);

      Element this_coll_dn_list = coll_requests_map.get(collection);
      if (this_coll_dn_list == null) {
        Element this_coll_request = GSXML.createBasicRequest(doc, GSXML.REQUEST_TYPE_PROCESS, GSPath.appendLink(collection, "DocumentMetadataRetrieve"), new UserContext());
        this_coll_request.appendChild(dm_param_list.cloneNode(true));
        this_coll_dn_list = doc.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
        this_coll_request.appendChild(this_coll_dn_list);
        coll_requests_map.put(collection, this_coll_dn_list);
        message.appendChild(this_coll_request);
      }

      this_coll_dn_list.appendChild(doc.importNode(dn, false));
    } // for each node

    // ok, send off the message
    Element dm_result = (Element)this.mr.process(message);

    String [] att_names = {GSXML.COLLECTION_ATT, GSXML.NODE_ID_ATT};
    // go throught he original list of doc nodes
    for (int i = 0; i < doc_nodes.getLength(); i++) {
      Element dn = (Element) doc_nodes.item(i);
      String collection = dn.getAttribute(GSXML.COLLECTION_ATT);
      String node_id = dn.getAttribute(GSXML.NODE_ID_ATT);
      // find the corresponding one in the result
      Element new_dn = GSXML.findMatchingElement(dm_result, GSXML.DOC_NODE_ELEM, att_names, new String[] {collection, node_id});
      if (new_dn != null) {
        Node new_meta = GSXML.getChildByTagName(new_dn, GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
        if (new_meta != null) {
          dn.appendChild(result_doc.importNode(new_meta, true));
        }
      }
    }
  }
}