source: trunk/gsdl/src/recpt/queryaction.cpp@ 800

/**********************************************************************
 *
 * queryaction.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * A component of the Greenstone digital library software
 * from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * 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.
 *
 * $Id: queryaction.cpp 800 1999-12-05 21:22:33Z sjboddie $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.31  1999/12/05 21:22:33  sjboddie
   tidied up cross-collection searching a bit

   Revision 1.30  1999/11/08 20:26:37  sjboddie
   added multiplevalue option to cgiarginfo

   Revision 1.29  1999/11/04 20:29:53  sjboddie
   small change to cross-collection searching

   Revision 1.28  1999/11/03 22:49:50  sjboddie
   A few changes to cross-collection searching for fao

   Revision 1.27  1999/11/01 21:53:27  sjboddie
   added cross-collection searching capability - still needs lots of
   work but the basic functionality is there

   Revision 1.26  1999/10/10 08:14:10  sjboddie
   - metadata now returns mp rather than array
   - redesigned browsing support (although it's not finished so
   won't currently work ;-)

   Revision 1.25  1999/09/24 04:49:39  sjboddie
   fixed up the query selection boxes to display properly if there's only
   a single index/sub-collection

   Revision 1.24  1999/09/22 03:44:31  sjboddie
   EndResults query filter option may now take '-1' for 'all'

   Revision 1.23  1999/09/21 11:34:42  sjboddie
   added Maxdocs queryfilter option which may be -1 for 'all'

   Revision 1.22  1999/09/07 23:08:51  rjmcnab
   removed some compiler warnings

   Revision 1.21  1999/09/07 04:56:57  sjboddie
   added GPL notice

   Revision 1.20  1999/08/25 04:47:55  sjboddie
   added advanced search option - other minor changes

   Revision 1.19  1999/08/13 04:17:24  sjboddie
   small change to do with new collection-level metadata

   Revision 1.18  1999/08/10 22:46:33  sjboddie
   changed format option result to QueryResults and added QueryLinks option

   Revision 1.17  1999/07/30 02:24:42  sjboddie
   added collectinfo argument to some functions

   Revision 1.16  1999/07/19 00:16:58  sjboddie
   no longer display documents that don't match all phrases in query string

   Revision 1.15  1999/07/16 08:33:36  rjmcnab
   Changed the logic for getting the results string slightly

   Revision 1.14  1999/07/16 03:41:29  sjboddie
   changed isApprox

   Revision 1.13  1999/07/16 00:19:01  sjboddie
   some changes to the way quoted queries are handled

   Revision 1.12  1999/07/09 02:17:55  rjmcnab
   Setting macros needed for a second query.

   Revision 1.11  1999/07/07 06:13:10  rjmcnab
   Added ability to combine two independant queries.

   Revision 1.10  1999/07/07 05:49:35  sjboddie
   had another crack at the format string code - created a new formattools
   module. It can now handle {If} and {Or} statements although there's a
   bug preventing nested if's and or's.

   Revision 1.9  1999/07/01 22:48:46  sjboddie
   had a go at getting a query result format string working

   Revision 1.8  1999/06/27 22:02:11  sjboddie
   author is added  to queryresults if there is one

   Revision 1.7  1999/06/26 01:10:18  rjmcnab
   Made h, i, and n arguments saved in the compressed arguments.

   Revision 1.6  1999/06/24 05:12:25  sjboddie
   lots of small changes

   Revision 1.5  1999/06/16 04:03:48  sjboddie
   Now sets "cl" arg to "search" when going to a document from a search
   results page. This allows the close book icon (in hierarchy toc) to
   take you back to the results page if that's where you came from.
   If you got to the document page somehow other than from a
   classification or a search (i.e. if "cl" isn't set) then the close
   book icon is disabled

   Revision 1.4  1999/06/16 02:08:38  sjboddie
   got queryaction working

   Revision 1.3  1999/03/25 03:06:45  sjboddie

   altered receptionist slightly so it now passes *collectproto to
   define_internal_macros and define_external_macros - need it
   for browseaction

   Revision 1.2  1999/03/03 20:26:50  rjmcnab

   Modified stuff.

   Revision 1.1  1999/02/28 22:45:21  rjmcnab

   Initial revision.

 */


#include "queryaction.h"
#include "querytools.h"
#include "formattools.h"
#include "cgiutils.h"
#include "OIDtools.h"

void colinfo_t::clear () {
  formatlistptr = NULL;
  browserptr = NULL;
}

void QueryResult_t::clear() {
  doc.clear();
  collection.clear();
}

queryaction::queryaction () {

  num_phrases = 0;

  // this action uses cgi variable "a"
  cgiarginfo arg_ainfo;
  arg_ainfo.shortname = "a";
  arg_ainfo.longname = "action";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "q";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "b" - 0 = simple, 1 = advanced
  arg_ainfo.shortname = "b";
  arg_ainfo.longname = "query mode";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "h"
  arg_ainfo.shortname = "h";
  arg_ainfo.longname = "main index";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "h2"
  arg_ainfo.shortname = "h2";
  arg_ainfo.longname = "main index for second query";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "j"
  arg_ainfo.shortname = "j";
  arg_ainfo.longname = "sub collection index";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "j2"
  arg_ainfo.shortname = "j2";
  arg_ainfo.longname = "sub collection index for second query";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "n"
  arg_ainfo.shortname = "n";
  arg_ainfo.longname = "language index";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "n2"
  arg_ainfo.shortname = "n2";
  arg_ainfo.longname = "language index for second query";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "q"
  arg_ainfo.shortname = "q";
  arg_ainfo.longname = "query string";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "q2"
  arg_ainfo.shortname = "q2";
  arg_ainfo.longname = "query string for second query";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "cq2" ""=don't combine, "and", "or", "not"
  arg_ainfo.shortname = "cq2";
  arg_ainfo.longname = "combine queries";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "t" - 1 = ranked 0 = boolean
  arg_ainfo.shortname = "t";
  arg_ainfo.longname = "search type";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "1";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "k"
  arg_ainfo.shortname = "k";
  arg_ainfo.longname = "casefolding";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "1";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "s"
  arg_ainfo.shortname = "s";
  arg_ainfo.longname = "stemming";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault ="0";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "m"
  arg_ainfo.shortname = "m";
  arg_ainfo.longname = "maximum number of documents";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "50";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "o"
  arg_ainfo.shortname = "o";
  arg_ainfo.longname = "hits per page";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "20";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "r"
  arg_ainfo.shortname = "r";
  arg_ainfo.longname = "start results from";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "1";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "ccs"
  arg_ainfo.shortname = "ccs";
  arg_ainfo.longname = "cross collection searching";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "ccp"
  arg_ainfo.shortname = "ccp";
  arg_ainfo.longname = "cross collection page";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // "cc"
  arg_ainfo.shortname = "cc";
  arg_ainfo.longname = "collections to search";
  arg_ainfo.multiplechar = true;
  arg_ainfo.multiplevalue = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

}

void queryaction::configure (const text_t &key, const text_tarray &cfgline) {
  action::configure (key, cfgline);
}

bool queryaction::init (ostream &logout) {
  return action::init (logout);
}

bool queryaction::check_cgiargs (cgiargsinfoclass &argsinfo, cgiargsclass &args, 
                 ostream &logout) {

  // check t argument
  int arg_t = args.getintarg("t");
  if (arg_t != 0 && arg_t != 1) {
    logout << "Warning: \"t\" argument out of range (" << arg_t << ")\n";
    cgiarginfo *tinfo = argsinfo.getarginfo ("t");
    if (tinfo != NULL) args["t"] = tinfo->argdefault;
  }

  // check k argument
  int arg_k = args.getintarg("k");
  if (arg_k != 0 && arg_k != 1) {
    logout << "Warning: \"k\" argument out of range (" << arg_k << ")\n";
    cgiarginfo *kinfo = argsinfo.getarginfo ("k");
    if (kinfo != NULL) args["k"] = kinfo->argdefault;
  }

  // check s argument
  int arg_s = args.getintarg("s");
  if (arg_s != 0 && arg_s != 1) {
    logout << "Warning: \"s\" argument out of range (" << arg_s << ")\n";
    cgiarginfo *sinfo = argsinfo.getarginfo ("s");
    if (sinfo != NULL) args["s"] = sinfo->argdefault;
  }

  // check m argument
  int arg_m = args.getintarg("m");
  if (arg_m < -1) {
    logout << "Warning: \"m\" argument less than -1 (" << arg_m << ")\n";
    cgiarginfo *minfo = argsinfo.getarginfo ("m");
    if (minfo != NULL) args["m"] = minfo->argdefault;
  }

  // check o argument
  int arg_o = args.getintarg("o");
  if (arg_o < -1) {
    logout << "Warning: \"o\" argument less than -1 (" << arg_o << ")\n";
    cgiarginfo *oinfo = argsinfo.getarginfo ("o");
    if (oinfo != NULL) args["o"] = oinfo->argdefault;
  }

  // check r argument
  int arg_r = args.getintarg("r");
  if (arg_r < 1) {
    logout << "Warning: \"r\" argument less than 1 (" << arg_r << ")\n";
    cgiarginfo *rinfo = argsinfo.getarginfo ("r");
    if (rinfo != NULL) args["r"] = rinfo->argdefault;
  }

  return true;
}

void queryaction::get_cgihead_info (cgiargsclass &/*args*/, recptprotolistclass * /*protos*/,
                    response_t &response, text_t &response_data, 
                    ostream &/*logout*/) {
  response = content;
  response_data = "text/html";
}

void queryaction::define_internal_macros (displayclass &disp, cgiargsclass &args, 
                      recptprotolistclass * /*protos*/, 
                      ostream &/*logout*/) {

  // define_internal_macros sets the following macros:

  // _quotedquery_  the part of the query string that was quoted for post-processing



  // The following macros are set later (in define_query_macros) as they can't be set until 
  // the query has been done.

  // _freqmsg_      the term frequency string

  // _resultline_   the "x documents matched the query" string

  // _prevfirst_    these are used when setting up the links to previous/next
  // _prevlast_     pages of results (_thisfirst_ and _thislast_ are used to set
  // _nextfirst_    the 'results x-x for query: xxxx' string in the title bar)
  // _nextlast_
  // _thisfirst_
  // _thislast_


  // get the quoted bits of the query string and set _quotedquery_
  text_tarray phrases;
  get_phrases (args["q"], phrases);
  num_phrases = phrases.size();
  text_tarray::const_iterator phere = phrases.begin();
  text_tarray::const_iterator pend = phrases.end();
  bool first = true;
  text_t quotedquery;
  while (phere != pend) {
    if (!first)
      if ((phere +1) == pend) quotedquery += " and ";
      else quotedquery += ", ";
    
    quotedquery += "\"" + *phere + "\"";
    first = false;
    phere ++;
  }
  if (args.getintarg("s")) quotedquery += "_textstemon_";
  disp.setmacro ("quotedquery", "query", quotedquery);
}

// sets the selection box macros _hselection_, _jselection_, and _nselection_.
void queryaction::set_option_macro (const text_t &macroname, text_t current_value,
                    const FilterOption_t &option, displayclass &disp) {
  
  if (option.validValues.empty()) return;
  else if (option.validValues.size() == 1) {
    disp.setmacro (macroname + "selection", "Global", "_" + option.defaultValue + "_");
    return;
  } 
  if (option.validValues.size() < 2) return;
  
  text_t macrovalue = "<select name=\"" + macroname + "\">\n";
  
  if (current_value.empty()) current_value = option.defaultValue;
  
  text_tarray::const_iterator thisvalue = option.validValues.begin();
  text_tarray::const_iterator endvalue = option.validValues.end();

  while (thisvalue != endvalue) {
    macrovalue += "<option value=\"" + *thisvalue + "\"";
    if (*thisvalue == current_value)
      macrovalue += " selected";
    macrovalue += ">_" + *thisvalue + "_\n";
    thisvalue ++;
  }
  macrovalue += "</select>\n";
  disp.setmacro (macroname + "selection", "Global", macrovalue);
}

void queryaction::define_external_macros (displayclass &disp, cgiargsclass &args, 
                      recptprotolistclass *protos, ostream &logout) {

  // define_external_macros sets the following macros:

  // some or all of these may not be required to be set
  // _hselection_, _h2selection_  the selection box for the main part of the index
  // _jselection_, _j2selection_  the selection box for the subcollection part of the index
  // _nselection_, _n2selection_  the selection box for the language part of the index
  // _cq2selection                the selection box for combining two queries
  
  
  // can't do anything if collectproto is null (i.e. no collection was specified)
  recptproto *collectproto = protos->getrecptproto (args["c"], logout);
  if (collectproto == NULL) return;

  comerror_t err;
  InfoFilterOptionsResponse_t response;
  InfoFilterOptionsRequest_t request;
  request.filterName = "QueryFilter";
  
  collectproto->get_filteroptions (args["c"], request, response, err, logout);
  if (err == noError) {
    
    FilterOption_tmap::const_iterator it;
    FilterOption_tmap::const_iterator end = response.filterOptions.end();
    
    // _hselection_ and _h2selection_ (Index)
    it = response.filterOptions.find ("Index");
    if (it != end) set_option_macro ("h", args["h"], (*it).second, disp);
    if (it != end) set_option_macro ("h2", args["h2"], (*it).second, disp);
    
    // _jselection_ and _j2selection_ (Subcollection)
    it = response.filterOptions.find ("Subcollection");
    if (it != end) set_option_macro ("j", args["j"], (*it).second, disp);
    if (it != end) set_option_macro ("j2", args["j2"], (*it).second, disp);
    
    // _nselection_ and _n2selection_ (Language)
    it = response.filterOptions.find ("Language");
    if (it != end) set_option_macro ("n", args["n"], (*it).second, disp);
    if (it != end) set_option_macro ("n2", args["n2"], (*it).second, disp);

    // _cq2selection_ (CombineQuery)
    it = response.filterOptions.find ("CombineQuery");
    if (it != end) set_option_macro ("cq2", args["cq2"], (*it).second, disp);
  }
}

void queryaction::output_ccp (cgiargsclass &args, recptprotolistclass *protos,
                  displayclass &disp, outconvertclass &outconvert,
                  ostream &textout, ostream &logout) {

  ColInfoResponse_t cinfo;
  comerror_t err;
  InfoFilterOptionsResponse_t fresponse;
  InfoFilterOptionsRequest_t frequest;
  frequest.filterName = "QueryFilter";

  text_t &index = args["h"];
  text_t &subcollection = args["j"];
  text_t &language = args["n"];

  text_tset collections;
  text_t arg_cc = args["cc"];
  decode_cgi_arg (arg_cc);
  splitchar (arg_cc.begin(), arg_cc.end(), ',', collections);

  textout << outconvert << disp << "_query:header_\n"
      << "<center>_navigationbar_</center><br>\n"
      << "<form name=QueryForm method=get action=\"_gwcgi_\">\n"
      << "<input type=hidden name=a value=\"q\">\n"
      << "<input type=hidden name=e value=\"_compressedoptions_\">\n"
      << "<input type=hidden name=ccp value=\"1\">\n"
      << "<center><table width=_pagewidth_><tr valign=top>\n"
      << "<td>Select collections to search for \"" << args["q"] 
      << "\" <i>(index=" << index << " subcollection=" << subcollection
      << " language=" << language << ")</i></td>\n"
      << "<td><input type=\"submit\" value=\"_query:textbeginsearch_\"></td>\n"
      << "</tr></table></center>\n"
      << "<center><table width=_pagewidth_>\n"
      << "<tr><td>\n";
  
  recptprotolistclass::iterator rprotolist_here = protos->begin();
  recptprotolistclass::iterator rprotolist_end = protos->end();
  while (rprotolist_here != rprotolist_end) {
    if ((*rprotolist_here).p != NULL) {
      
      text_tarray collist;
      (*rprotolist_here).p->get_collection_list (collist, err, logout);
      if (err == noError) {
    text_tarray::iterator collist_here = collist.begin();
    text_tarray::iterator collist_end = collist.end();
    while (collist_here != collist_end) {
      
      (*rprotolist_here).p->get_collectinfo (*collist_here, cinfo, err, logout);
      //      if (err == noError && cinfo.isPublic && (cinfo.buildDate > 0)) {
      if (err == noError && (cinfo.buildDate > 0)) {
        
        (*rprotolist_here).p->get_filteroptions (*collist_here, frequest, fresponse, err, logout);
        if (err == noError) {
          
          FilterOption_tmap::const_iterator it;
          FilterOption_tmap::const_iterator end = fresponse.filterOptions.end();
          if (!index.empty()) {
        it = fresponse.filterOptions.find ("Index");
        if (it == end) {collist_here ++; continue;}
        text_tarray::const_iterator there = (*it).second.validValues.begin();
        text_tarray::const_iterator tend = (*it).second.validValues.end();
        while (there != tend) {
          if (*there == index) break;
          there ++;
        }
        if (there == tend) {collist_here++; continue;}
          }
          if (!subcollection.empty()) {
        it = fresponse.filterOptions.find ("Subcollection");
        if (it == end) {collist_here++; continue;}
        text_tarray::const_iterator there = (*it).second.validValues.begin();
        text_tarray::const_iterator tend = (*it).second.validValues.end();
        while (there != tend) {
          if (*there == subcollection) break;
          there ++;
        }
        if (there == tend) {collist_here++; continue;}
          }
          if (!language.empty()) {
        it = fresponse.filterOptions.find ("Language");
        if (it == end) {collist_here++; continue;}
        text_tarray::const_iterator there = (*it).second.validValues.begin();
        text_tarray::const_iterator tend = (*it).second.validValues.end();
        while (there != tend) {
          if (*there == language) break;
          there ++;
        }
        if (there == tend) {collist_here++; continue;}
          }
        
          // we've got a matching collection
          textout << "<input type=checkbox";

          text_tset::const_iterator t = collections.find (*collist_here);
          if (t != collections.end()) textout << " checked";

          textout << outconvert 
              << " name=cc value=\"" << *collist_here << "\">";
          
          if (!cinfo.collectionmeta["collectionname"].empty())
        textout << outconvert << disp << cinfo.collectionmeta["collectionname"];
          else 
        textout << outconvert << *collist_here;
          
          textout << "<br>\n";
          
        }
      }
      collist_here ++;
    }
      }
    }
    rprotolist_here ++;
  }
  textout << outconvert << disp 
      << "</td></tr></table></center>\n"
      << "</form>\n"
      << "_query:footer_\n";
  
}

bool queryaction::do_action (cgiargsclass &args, recptprotolistclass *protos, 
                 browsermapclass *browsers, displayclass &disp, 
                 outconvertclass &outconvert, ostream &textout, 
                 ostream &logout) {
  
  if (args["ccs"] == 1) {
    // cross collection searching (we'll just borrow the el argument
    // from extlinkaction for now - this will probably want to use 
    // a separate argument eventually)
    //    if (args["ccp"] != 1 && args["el"] != "direct") {
      // display the cross collection search page
    //      output_ccp (args, protos, disp, outconvert, textout, logout);
    //    } else {
      // query the selected collections

    text_t::const_iterator b = args["cc"].begin();
    text_t::const_iterator e = args["cc"].end();
    if (!args["cc"].empty() && (findchar (b, e, ',') != e))
      if (!search_multiple_collections (args, protos, browsers, disp, outconvert,
                    textout, logout)) return false;
      else return true;
  }

  // simply query the current collection
  if (!search_single_collection (args, protos, browsers, disp, outconvert,
                 textout, logout)) return false;
  
  return true;
}

bool queryaction::search_multiple_collections (cgiargsclass &args, recptprotolistclass *protos,
                           browsermapclass *browsers, displayclass &disp,
                           outconvertclass &outconvert, ostream &textout,
                           ostream &logout) {

  text_tarray collections;
  
  text_t arg_cc = args["cc"];
  decode_cgi_arg (arg_cc);
  splitchar (arg_cc.begin(), arg_cc.end(), ',', collections);

  if (collections.empty()) {
    logout << "queryaction::search_multiple_collections: No collections "
       << "set for doing multiple query - will search current collection\n";
    textout << outconvert << disp << "_query:textwarningnocollections_\n";
    return search_single_collection (args, protos, browsers, disp, 
                     outconvert, textout, logout);
  }

  // queryaction uses "VList" browser to display results,
  // a queries clasification is "Search"
  text_t browsertype = "VList";
  text_t classification = "Search";

  QueryResult_tset results;
  map<text_t, colinfo_t, lttext_t> colinfomap;

  ColInfoResponse_t cinfo;
  comerror_t err;
  FilterRequest_t request;
  FilterResponse_t response;
  request.filterResultOptions = FROID | FRmetadata | FRtermFreq | FRranking;
  text_t formattedstring = args["q"];
  text_t freqmsg = "_textfreqmsg1_";
  int numdocs = 0;
  isapprox isApprox = Exact;
  text_tset colnamedata;
  colnamedata.insert ("collectionname");

  format_querystring (formattedstring, args.getintarg("b"));
  set_queryfilter_options (request, formattedstring, args);

  // need to retrieve maxdocs matches for each collection
  // (will eventually want to tidy this up, do so caching etc.)
  OptionValue_t option;
  option.name = "StartResults";
  option.value = "1";
  request.filterOptions.push_back (option);
  
  option.name = "EndResults";
  option.value = args["m"];
  request.filterOptions.push_back (option);

  text_tarray::iterator col_here = collections.begin();
  text_tarray::iterator col_end = collections.end();

  while (col_here != col_end) {

    request.fields.erase (request.fields.begin(), request.fields.end());
    request.getParents = false;

    recptproto *collectproto = protos->getrecptproto (*col_here, logout);
    if (collectproto == NULL) {
      logout << outconvert << "queryaction::search_multiple_collections: " << *col_here 
         << " collection has a NULL collectproto, ignoring\n";
      col_here ++;
      continue;
    }
    collectproto->get_collectinfo (*col_here, cinfo, err, logout);
    
    browserclass *bptr = browsers->getbrowser (browsertype);

    // get the formatstring if there is one 
    text_t formatstring;
    if (!get_formatstring (classification, browsertype, 
               cinfo.format, formatstring))
      formatstring = bptr->get_default_formatstring();

    bptr->load_metadata_defaults (request.fields);

    format_t *formatlistptr = new format_t();
    parse_formatstring (formatstring, formatlistptr, request.fields, request.getParents);

    colinfo_t thiscolinfo;
    thiscolinfo.formatlistptr = formatlistptr;
    thiscolinfo.browserptr = bptr;
    colinfomap[*col_here] = thiscolinfo;
    
    // do the query
    collectproto->filter (*col_here, request, response, err, logout);
    if (err != noError) {
      outconvertclass text_t2ascii;
      logout << text_t2ascii
         << "queryaction::search_multiple_collections: call to QueryFilter failed "
         << "for " << *col_here << " collection (" << get_comerror_string (err) << ")\n";
      return false;
    }

    if (isApprox == Exact)
      isApprox = response.isApprox;
    else if (isApprox == MoreThan)
      if (response.isApprox == Approximate)
    isApprox = response.isApprox;

    text_t collectionname = *col_here;
    FilterResponse_t nresponse;
    if (get_info ("collection", *col_here, colnamedata, false, collectproto, nresponse, logout)) {
      if (!nresponse.docInfo[0].metadata["collectionname"].values[0].empty())
    collectionname = nresponse.docInfo[0].metadata["collectionname"].values[0];
    }

    TermInfo_tarray::const_iterator this_term = response.termInfo.begin();
    TermInfo_tarray::const_iterator end_term = response.termInfo.end();
    freqmsg += "<br><b>" + collectionname + "</b>: ";
    while (this_term != end_term) {
      freqmsg += (*this_term).term + ": " + (*this_term).freq;
      if ((this_term + 1) != end_term)
    freqmsg += ", ";
      this_term ++;
    }
    
    if (response.numDocs > 0) {
      numdocs += response.numDocs;

      QueryResult_t thisresult;
      thisresult.collection = *col_here;
      ResultDocInfo_tarray::iterator doc_here = response.docInfo.begin();
      ResultDocInfo_tarray::iterator doc_end = response.docInfo.end();
      while (doc_here != doc_end) {
    thisresult.doc = *doc_here;
    results.insert (thisresult);
    doc_here ++;
      }
    }
    col_here ++;
  }

  disp.setmacro ("freqmsg", "query", freqmsg);

  text_t resline;
  if (num_phrases > 0) isApprox = Exact;
  if (isApprox == Approximate) resline = "_textapprox_";
  else if (isApprox == MoreThan) resline = "_textmorethan_";
  
  if (numdocs == 0) resline = "_textnodocs_";
  else if (numdocs == 1) resline += "_text1doc_";
  else resline += text_t(numdocs) + " _textlotsdocs_";
  disp.setmacro("resultline", "query", resline);

  QueryResult_tset::iterator res_here = results.begin();
  QueryResult_tset::iterator res_end = results.end();
  text_tset metadata; // empty !!
  bool getParents = false; // don't care !!
  recptproto *collectproto = NULL;
  bool use_table;
  ResultDocInfo_t thisdoc;
  format_t *formatlistptr = NULL;
  browserclass *browserptr = NULL;

  int maxdocs = args.getintarg("m");
  int firstdoc = args.getintarg("r");
  int hitsperpage = args.getintarg("o");
  if (numdocs > maxdocs) numdocs = maxdocs;
  if (hitsperpage == -1) hitsperpage = numdocs;

  // set up _thisfirst_ and _thislast_ macros
  disp.setmacro ("thisfirst", "query", firstdoc);
  int thislast = firstdoc + (hitsperpage - 1);
  if (thislast > numdocs) thislast = numdocs;
  disp.setmacro ("thislast", "query", thislast);

  // set up _prevfirst_ and _prevlast_ macros
  if (firstdoc > 1) {
    disp.setmacro ("prevlast", "query", firstdoc - 1);
    int prevfirst = firstdoc - hitsperpage;
    if (prevfirst < 1) prevfirst = 1;
    disp.setmacro ("prevfirst", "query", prevfirst);
  }

  // set up _nextfirst_ and _nextlast_ macros
  if (thislast < numdocs) {
    disp.setmacro ("nextfirst", "query", thislast + 1);
    int nextlast = thislast + hitsperpage;
    if (nextlast > numdocs) nextlast = numdocs;
    disp.setmacro ("nextlast", "query", nextlast);
  }

  textout << outconvert << disp << "_query:header_\n"
      << "_query:content_";

  int count = 1;

  // output results
  while (res_here != res_end) {
    if (count < firstdoc) {count ++; res_here ++; continue;}
    if (count > thislast) break;
    formatlistptr = colinfomap[(*res_here).collection].formatlistptr;
    browserptr = colinfomap[(*res_here).collection].browserptr;
    thisdoc = (*res_here).doc;
    use_table = is_table_content (formatlistptr);
    browserptr->output_section_group (thisdoc, args, (*res_here).collection, 0, 
                          formatlistptr, use_table, metadata, getParents, 
                          collectproto, disp, outconvert, textout, logout);
    //    textout << outconvert << "(ranking: " << (*res_here).doc.ranking << ")\n";
    res_here ++;
    count ++;
  }

  textout << outconvert << disp << "_query:footer_";
  
  // clean up the format_t pointers
  map<text_t, colinfo_t, lttext_t>::iterator here =  colinfomap.begin();
  map<text_t, colinfo_t, lttext_t>::iterator end =  colinfomap.end();
  while (here != end) {
    delete ((*here).second.formatlistptr);
    here ++;
  }
  return true;
}

bool queryaction::search_single_collection (cgiargsclass &args, recptprotolistclass *protos,
                        browsermapclass *browsers, displayclass &disp,
                        outconvertclass &outconvert, ostream &textout,
                        ostream &logout) {

  recptproto *collectproto = protos->getrecptproto (args["c"], logout);
  if (collectproto == NULL) {
    logout << outconvert << "queryaction::search_single_collection: " << args["c"]
       << " collection has a NULL collectproto\n";
    return false;
  }

  // queryaction uses "VList" browser to display results,
  // a queries clasification is "Search"
  text_t browsertype = "VList";
  text_t classification = "Search";

  ColInfoResponse_t cinfo;
  comerror_t err;
  collectproto->get_collectinfo (args["c"], cinfo, err, logout);
    
  browserclass *bptr = browsers->getbrowser (browsertype);

  // get the formatstring if there is one 
  text_t formatstring;
  if (!get_formatstring (classification, browsertype, 
             cinfo.format, formatstring))
    formatstring = bptr->get_default_formatstring();

  FilterRequest_t request;
  FilterResponse_t response;
  bptr->set_filter_options (request, args);
  bptr->load_metadata_defaults (request.fields);

  format_t *formatlistptr = new format_t();
  parse_formatstring (formatstring, formatlistptr, request.fields, request.getParents);
    
  // do the query
  request.filterResultOptions = FROID | FRmetadata | FRtermFreq;
  text_t formattedstring = args["q"];
  format_querystring (formattedstring, args.getintarg("b"));
  set_queryfilter_options (request, formattedstring, args);
  collectproto->filter (args["c"], request, response, err, logout);
  if (err != noError) {
    outconvertclass text_t2ascii;
    logout << text_t2ascii
       << "queryaction::search_single_collections: call to QueryFilter failed "
       << "for " << args["c"] << " collection (" << get_comerror_string (err) << ")\n";
    return false;
  }
  
  define_query_macros (args, disp, response);

  textout << outconvert << disp << "_query:header_\n"
      << "_query:content_";

  // output the results
  bool use_table = is_table_content (formatlistptr);
  bptr->output_section_group (response, args, "", 0, formatlistptr, 
                  use_table, request.fields, request.getParents, 
                  collectproto, disp, outconvert, textout, logout);
  

  textout << outconvert << disp << "_query:footer_";
  
  delete (formatlistptr);
  
  return true;
}
  
// define_query_macros sets the macros that couldn't be set until the
// query had been done. Those macros are _freqmsg_, _quotedquery_,
// _resultline_, _nextfirst_, _nextlast_, _prevfirst_, _prevlast_,
// _thisfirst_, and _thislast_
void queryaction::define_query_macros (cgiargsclass &args, displayclass &disp, 
                       const FilterResponse_t &response) { 
  // set up _freqmsg_ and _quotedquery_ macros
  text_t freqmsg = "_textfreqmsg1_";
  TermInfo_tarray::const_iterator this_term = response.termInfo.begin();
  TermInfo_tarray::const_iterator end_term = response.termInfo.end();
  while (this_term != end_term) {
    freqmsg += (*this_term).term + ": " + (*this_term).freq;
    if ((this_term + 1) != end_term)
      freqmsg += ", ";
    this_term ++;
  }
  
  disp.setmacro ("freqmsg", "query", freqmsg);


  // set up _resultline_ macro
  text_t resline;
  int maxdocs = args.getintarg("m");
  int numdocs = response.numDocs;
  if (maxdocs == -1) maxdocs = response.numDocs;
  isapprox isApprox = response.isApprox;

  // if there were phrases (post-processing) we're not going to include 
  // those documents that didn't match 
  if (num_phrases > 0) isApprox = Exact;

  if (isApprox == Approximate) resline = "_textapprox_";
  else if (isApprox == MoreThan) resline = "_textmorethan_";
  
  if (numdocs == 0) resline = "_textnodocs_";
  else if (numdocs == 1) resline += "_text1doc_";
  else resline += text_t(numdocs) + " _textlotsdocs_";
  
  disp.setmacro("resultline", "query", resline);

  int firstdoc = args.getintarg("r");
  int hitsperpage = args.getintarg("o");
  if (hitsperpage == -1) hitsperpage = numdocs;

  // set up _thisfirst_ and _thislast_ macros
  disp.setmacro ("thisfirst", "query", firstdoc);
  int thislast = firstdoc + (hitsperpage - 1);
  if (thislast > numdocs) thislast = numdocs;
  disp.setmacro ("thislast", "query", thislast);

  // set up _prevfirst_ and _prevlast_ macros
  if (firstdoc > 1) {
    disp.setmacro ("prevlast", "query", firstdoc - 1);
    int prevfirst = firstdoc - hitsperpage;
    if (prevfirst < 1) prevfirst = 1;
    disp.setmacro ("prevfirst", "query", prevfirst);
  }

  // set up _nextfirst_ and _nextlast_ macros
  if (thislast < numdocs) {
    disp.setmacro ("nextfirst", "query", thislast + 1);
    int nextlast = thislast + hitsperpage;
    if (nextlast > numdocs) nextlast = numdocs;
    disp.setmacro ("nextlast", "query", nextlast);
  }
}