source: trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2MGSearch.java@ 4012

/*
 *    GS2MGSearch.java
 *    Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
 *
 *    This program is free software; you can redistribute it and/or modify
 *   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.service;


// Greenstone classes
import org.greenstone.mg.*;
import org.greenstone.gsdl3.util.*;

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

// General Java classes
import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Vector;


/**
 *
 * @author <a href="mailto:[email protected]">Katherine Don</a>
 * @author <a href="mailto:[email protected]">Michael Dewsnip</a>
 * @version $Revision: 4012 $
 */

public class GS2MGSearch 
    extends GS2Search {


    private MGWrapper mg_src_ = null;


    /** constructor */
    public GS2MGSearch()
    {
    mg_src_ = new MGWrapper();
    }


    /** this creates all teh params and appends them to param_list.
     * if display=true it creates the text strings version
     * otherwise it creates the description version
     */
    protected boolean createTextQueryParamList(Element param_list, boolean display,
                           String lang)
    {
    // the order they are specified here is the order they appear on 
    // the query form
    createParameter(INDEX_PARAM, param_list, display, lang);
    createParameter(CASE_PARAM, param_list, display, lang);
    createParameter(STEM_PARAM, param_list, display, lang);
    createParameter(MATCH_PARAM, param_list, display, lang);
    createParameter(MAXDOCS_PARAM, param_list, display, lang);
    createParameter(QUERY_PARAM, param_list, display, lang);

    return true;
    }


    /** Creates a display element containing all the text strings needed to display
    the service page, in the language specified */
    protected Element createServiceDisplay(String service, String lang)
    {
    // Create a service display for the basic text query service
    return super.createServiceDisplay(service, lang);
    }


    /** Process a text query */
    protected Element processTextQuery(Element request)
    {
    // Create a new (empty) result message
    Element result = doc_.createElement(GSXML.RESPONSE_ELEM);
    result.setAttribute(GSXML.FROM_ATT, TEXT_QUERY_SERVICE);
    result.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_PROCESS);

    // Get the parameters of the request
    Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
    if (param_list == null) {
        System.err.println("Error: TextQuery request had no paramList.");
        return result;  // Return the empty result
    }

    // Process the request parameters
    HashMap params = GSXML.extractParams(param_list, false);

    // Make sure a query has been specified
    String query = (String) params.get(QUERY_PARAM);
    if (query == null || query.equals("")) {
        return result;  // Return the empty result
    }

    // If an index hasn't been specified, use the default
    String index = (String) params.get(INDEX_PARAM); 
    if (index == null) {
        index = default_index_;
    }

    // The location of the MG index and text files
    String basedir = GSFile.collectionBaseDir(site_home_, cluster_name_) +
                       File.separatorChar;  // Needed for MG
    String textdir = GSFile.collectionTextPath(cluster_name_);
    String indexpath = GSFile.collectionIndexPath(cluster_name_, index);
    mg_src_.setIndex(indexpath);

    // set the mg query parameters to the values the user has specified
    setStandardQueryParams(params);
    mg_src_.runQuery(basedir, textdir, query);
    MGQueryResult mqr = mg_src_.getQueryResult();
    long totalDocs = mqr.getTotalDocs();

    // Get the docnums out, and convert to HASH ids
    Vector docs = mqr.getDocs();
    if (docs.size() == 0) {
        System.err.println("GS2MGSearch: Warning: No results found...\n");
    }

    // Create a metadata list to store information about the query results
    Element metadata_list = doc_.createElement(GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER); 
    result.appendChild(metadata_list);

    // Add a metadata element specifying the number of matching documents
    Element num_matches_elem = doc_.createElement(GSXML.METADATA_ELEM);
    num_matches_elem.setAttribute(GSXML.NAME_ATT, "numDocsMatched");
    num_matches_elem.setAttribute(GSXML.VALUE_ATT, "" + totalDocs);
    metadata_list.appendChild(num_matches_elem);

    // Create a document list to store the matching documents, and add them
    Element document_list = doc_.createElement(GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
    result.appendChild(document_list);
    for (int d = 0; d < docs.size(); d++) {
        long docnum = ((MGDocInfo) docs.elementAt(d)).num_;
        String doc_id = gdbm_src_.docnum2Oid(docnum);
        Element doc_node = createDocumentNodeElement(doc_id);
        document_list.appendChild(doc_node);
    }

    // Create a term list to store the term information, and add it
    Element term_list = doc_.createElement(GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
    result.appendChild(term_list);
    Vector terms = mqr.getTerms();
    for (int t = 0; t < terms.size(); t++) {
        MGTermInfo term_info = (MGTermInfo) terms.get(t);

        String term = term_info.term_;
        int stem_method = term_info.stem_method_;
        Vector equiv_terms = term_info.equiv_terms_;

        Element term_elem = doc_.createElement(GSXML.TERM_ELEM);
        term_elem.setAttribute(GSXML.NAME_ATT, term);
        term_elem.setAttribute(STEM_ATT, "" + stem_method);

        Element equiv_term_list = doc_.createElement(EQUIV_TERM_ELEM+GSXML.LIST_MODIFIER);
        term_elem.appendChild(equiv_term_list);

        long total_term_freq = 0;
        for (int et = 0; et < equiv_terms.size(); et++) {
        MGEquivTermInfo equiv_term_info = (MGEquivTermInfo) equiv_terms.get(et);

        Element equiv_term_elem = doc_.createElement(GSXML.TERM_ELEM);
        equiv_term_elem.setAttribute(GSXML.NAME_ATT, equiv_term_info.term_);
        equiv_term_elem.setAttribute(NUM_DOCS_MATCH_ATT, "" + equiv_term_info.match_docs_);
        equiv_term_elem.setAttribute(FREQ_ATT, "" + equiv_term_info.term_freq_);
        equiv_term_list.appendChild(equiv_term_elem);

        total_term_freq += equiv_term_info.term_freq_;
        }

        term_elem.setAttribute(FREQ_ATT, "" + total_term_freq);
        term_list.appendChild(term_elem);
    }

    return result;
    }


    // should probably use a list rather than map
    protected boolean setStandardQueryParams(HashMap params)
    {
    // set the default ones
    mg_src_.setReturnTerms(true);
    Set entries = params.entrySet();
    Iterator i = entries.iterator();
    while (i.hasNext()) {
        Map.Entry m = (Map.Entry)i.next();
        String name = (String)m.getKey();
        String value = (String)m.getValue();

        if (name.equals(CASE_PARAM)) {
        boolean val = (value.equals(BOOLEAN_PARAM_ON) ? true : false);
        mg_src_.setCase(val);
        }
        else if (name.equals(STEM_PARAM)) {
        boolean val = (value.equals(BOOLEAN_PARAM_ON) ? true : false);
        mg_src_.setStem(val);
        }
        else if (name.equals(MATCH_PARAM)) {
        int mode = (value.equals(MATCH_PARAM_ALL) ? 1 : 0);
        mg_src_.setMatchMode(mode);
        }
        else if (name.equals(MAXDOCS_PARAM)) {
        int docs = Integer.parseInt(value);
        mg_src_.setMaxDocs(docs);
        } // ignore any others
    }
    return true;
    }
}