source: gs3-extensions/audioDB/trunk/src/src/java/org/greenstone/gsdl3/service/GS2AudioDBSearch.java@ 30411

/*
 *    GS2AudioDBSearch.java
 *    Copyright (C) 2011 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.gsdl3.util.*;

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

// java
import java.util.Vector;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Iterator;
import java.io.File;

import org.apache.log4j.*;

public class GS2AudioDBSearch extends AbstractGS2AudioSearch {

    static Logger logger = Logger.getLogger (org.greenstone.gsdl3.service.GS2AudioDBSearch.class.getName ());

    protected static final String OFFSET_PARAM  = "offset";
    protected static final String LENGTH_PARAM  = "length";
    protected static final String RADIUS_PARAM  = "radius";
    protected static final String MAXDOCS_PARAM = "maxDocs";

    protected static final String AUDIODB_DEFAULT_DIRECTORY = "audioDB";
    protected static final String ADB_FILENAME = "lsh-features.adb";
    
    protected AudioDBWrapper audiodb_src = null;
        
    /** constructor */
    public GS2AudioDBSearch () {
    if(this.audiodb_src == null){
        this.audiodb_src = new AudioDBWrapper ();
        }
    }
    
     /** do the actual query */
    protected Element processAudioQuery (Element request) {
    // MG needs to be synchronized (this inspiration for this class)
    // Since it is not known how concurrent audioDB can be, play it safe for
    // now and also require synchronization

        synchronized(this.audiodb_src) {
        // Create a new (empty) result message ('doc' is in ServiceRack.java)
        Document result_doc = XMLConverter.newDOM();
        Element result = result_doc.createElement (GSXML.RESPONSE_ELEM);

        // Rather than QUERY_SERVICE use "TextQuery" 
        // => makes the result looks the same as a text query
        result.setAttribute (GSXML.FROM_ATT, "TextQuery"); 
        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) {
        logger.error ("AudioDB AudioQuery 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 = AUDIODB_DEFAULT_DIRECTORY; 
        }
        
        // The location of the audioDB index
        String toplevel_index_dir = GSFile.collectionIndexDir (this.site_home, this.cluster_name);
        String audioDB_index_dir = toplevel_index_dir + File.separatorChar + index;
        String assoc_index_dir = toplevel_index_dir + File.separatorChar + "assoc";

        // set the audioDB query parameters to the values the user has specified
        setStandardQueryParams (params);
        
        this.audiodb_src.runQuery (audioDB_index_dir, ADB_FILENAME, assoc_index_dir, query);
        Vector docs = this.audiodb_src.getQueryResult ();

        if (docs.isEmpty()) {
        // something has gone wrong
        GSXML.addError (result, "Couldn't query the audioDB database", GSXML.ERROR_TYPE_SYSTEM);
        return result;
        }
        long totalDocs = docs.size();
        
        // Get the docnums out, and convert to HASH ids
        if (docs.size () == 0) {
        logger.error ("No results found...\n");
        }
        
        // Create a metadata list to store information about the query results
        Element metadata_list = result_doc.createElement (GSXML.METADATA_ELEM+GSXML.LIST_MODIFIER);
        result.appendChild (metadata_list);
        
        // Add a metadata element specifying the number of matching documents
        // because the total number is just the number returned, use numDocsReturned, not numDocsMatched
        GSXML.addMetadata (metadata_list, "numDocsReturned", ""+totalDocs);
        // add a metadata item to specify what actual query was done - eg if stuff was stripped out etc. and then we can use the query later, cos we don't know which parameter was the query
        GSXML.addMetadata (metadata_list, "query", query);
        
        if (docs.size () > 0) {
        // Create a document list to store the matching documents, and add them
        Element document_list = result_doc.createElement (GSXML.DOC_NODE_ELEM+GSXML.LIST_MODIFIER);
        result.appendChild (document_list);
        for (int d = 0; d < docs.size (); d++) {
            AudioDBDocInfo adb_doc = (AudioDBDocInfo) docs.elementAt(d);

            String doc_id  = adb_doc.getDocID();
            double rank    = adb_doc.getTopRank();
            String offsets = adb_doc.getOffsetList();

            Element doc_node = createDocNode (result_doc, doc_id, Double.toString (rank));
            doc_node.setAttribute("frameOffset", offsets);

            document_list.appendChild (doc_node);
        }
        }
        
        // Create an empty term list as a place holder for the term information
        Element term_list = result_doc.createElement (GSXML.TERM_ELEM+GSXML.LIST_MODIFIER);
        result.appendChild (term_list);
        
        return result;
    }//end of synchronized
    }
    
    // should probably use a list rather than map
    protected boolean setStandardQueryParams(HashMap params)
    {
    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(OFFSET_PARAM)) {
        int offset = Integer.parseInt(value);
        this.audiodb_src.setOffset(offset);
        }
        else if (name.equals(LENGTH_PARAM)) {
        int length = Integer.parseInt(value);
        this.audiodb_src.setLength(length);
        }
        else if (name.equals(RADIUS_PARAM)) {
        double radius = Double.parseDouble(value);
        this.audiodb_src.setRadius(radius);
        }
        else if (name.equals(MAXDOCS_PARAM)) {
        int docs = Integer.parseInt(value);
        this.audiodb_src.setMaxDocs(docs);
        } // ignore any others
    }
    return true;
    }
    
    
}