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

/**********************************************************************
 *
 * 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 962 2000-02-21 21:57:50Z sjboddie $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.36  2000/02/21 21:57:48  sjboddie
   actions are now configured with gsdlhome

   Revision 1.35  2000/02/17 02:35:04  sjboddie
   tidied up search history stuff a bit - replaced strings with macros

   Revision 1.34  2000/02/15 22:53:52  kjm18
   search history stuff added.

   Revision 1.33  2000/01/24 22:57:59  sjboddie
   fixed bug in cross-collection searching, tidied up a bit

   Revision 1.32  1999/12/13 02:54:11  davidb
   Support for cross collection searching (CCS)

   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"
//#include "infodbclass.h"
#include "fileutil.h"
#include "text_t.h"
#include "historydb.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);

  // "hd" history display  - search history only displayed when
  // this var set.
  arg_ainfo.shortname = "hd";
  arg_ainfo.longname = "history display";
  arg_ainfo.multiplechar = false;
  arg_ainfo.multiplevalue = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);
        

 // "hs"  save - set to 1 in query form, so only save when submit
  // query
  // 0 = no save 1 = save
  arg_ainfo.shortname = "hs";
  arg_ainfo.longname = "history save";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::mustnot;
  argsinfo.addarginfo (NULL, arg_ainfo);


  // "hcl" compress the list (show only the last 5)
  // 0 = expand, 1 = compress

  arg_ainfo.shortname = "hcl";
  arg_ainfo.longname = "history compress list";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "1";
  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;
  }
  //check hd argument
    int arg_hd = args.getintarg("hd");
    if (arg_hd !=0 && arg_hd !=1) {
      logout << "Warning: \"hd\" argument out of range (" << arg_hd << ")\n";
          cgiarginfo *hdinfo = argsinfo.getarginfo ("hd");
          if (hdinfo != NULL) args["hd"] = hdinfo->argdefault;
    }  
  //check hs argument
  int arg_hs = args.getintarg("hs");
  if (arg_hs !=0 && arg_hs !=1) {
    logout << "Warning: \"hs\" argument out of range (" << arg_hs << ")\n";
    cgiarginfo *hsinfo = argsinfo.getarginfo ("hs");
    if (hsinfo != NULL) args["hs"] = hsinfo->argdefault;
  }

  // chech hcl argument
  int arg_hcl = args.getintarg("hcl");
  if (arg_hcl !=0 && arg_hcl !=1) {
    logout << "Warning: \"hcl\" argument out of range (" << arg_hcl << ")\n";
    cgiarginfo *hclinfo = argsinfo.getarginfo ("hcl");
    if (hclinfo != NULL) args["hcl"] = hclinfo->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);

    // define_history_macros(disp, args, protos, logout);
  }
} // define external macros

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

  // defines the following macros

  // _searchhistorylist_

  text_t historylist;
  int arghd = args.getintarg("hd");
  if (arghd != 1) {
    historylist="";
  }
  else {
    historylist = "<!-- Search History List -->\n";
   
    text_t userid = args["z"];
    text_tarray entries;
    if (get_history_info (userid, entries, gsdlhome, logout)) {
      int count = 1;
      text_tarray::iterator here = entries.begin();
      text_tarray::iterator end = entries.end();
      int size=(int)entries.size();
      if (args["hcl"]==1&&size>5) { // compress the list 
    here = end-5;
    count=size-4;
      }
      historylist += "<table align=center width=500 border=0>\n";
      historylist += "<tr><td width=300 align=center>";
      historylist += "<a href=\"_httpclearhistory_\">_textclearhistory_</a></td>\n";

      if (size>5&&args["hcl"]==1) { //compress the list, show the expand button
       
      historylist += "<td><a href=\"_gwcgi_?e=_compressedoptions_&a=q&hcl=0\">_textexpand_</a></td>\n";
      }
      else if (size >5 && args["hcl"]==0) { // expand the list, show contract button
    historylist += "<td><a href=\"_gwcgi_?e=_compressedoptions_&a=q&hcl=1\">_textcontract_</a></td>\n";
      }
      historylist += "</table>\n";
      historylist += "<table align=center width=500 border=1>\n<tr><th colspan=4 align=center>";
      historylist += "_textsearchhistory_</th></tr>\n";
      historylist += "<tr><th width=40>#</th>\n<th width=340>_textquery_</th>\n";
      historylist += "<th width=60>_textresults_</th><th width=60>_textview_</th></tr>\n";

      while (here !=end ) {
    text_t c;
    text_t query;
    text_t numdocs;
    text_t cgiargs;
    text_t  userinfo;
    split_saved_query(*here,c, numdocs, cgiargs);
    parse_saved_args(cgiargs, "q", query); // get query string out
    decode_cgi_arg(query); // un cgisafe it
    
    format_user_info(cgiargs, userinfo, protos, logout);
    
    historylist += "<tr> <td width=40 align=center>"+c+"</td>\n";
    historylist += "<td width=340 align=left>"+query+"</td><td width=60 align=center>"+numdocs+"</td>\n";
    historylist += "<td width=60 align=center><a href=\"_gwcgi_?e=_compressedoptions_&";
    historylist += *here+"\"><img name=\"display\" src=\"_httpicondisplay_\" width=_widthdisplay_ ";
    historylist += "height=_heightdisplay_ border=\"0\" alt=\"" + userinfo +"\"></a></td></tr>\n";
    here++;
    count++;
      }
      historylist+="</table>\n\n";
     
    } // if
    else {
      historylist += "_textnohistory_";
    }
    historylist += "<p><! ---- end of history list ----->\n";
  } // else display list
  disp.setmacro("searchhistorylist", "query", historylist);
  
} // define history macros

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") {
    if (!args["cc"].empty()) {
      // query the selected collections
      text_t::const_iterator b = args["cc"].begin();
      text_t::const_iterator e = args["cc"].end();
      if (findchar (b, e, ',') != e) {
    if (!search_multiple_collections (args, protos, browsers, disp, outconvert,
                      textout, logout)) return false;
    return true;
      } else {
    if (!search_single_collection (args, args["cc"], protos, browsers, disp, 
                       outconvert, textout, logout)) return false;
    return true;
      }
    }
  }

  // simply query the current collection
  if (!search_single_collection (args, args["c"], 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, args["c"], 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;

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

  map<text_t, int, lttext_t> termfreqs;
  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;

    TermInfo_tarray::const_iterator this_term = response.termInfo.begin();
    TermInfo_tarray::const_iterator end_term = response.termInfo.end();
    while (this_term != end_term) {
      termfreqs[(*this_term).term] += (*this_term).freq;
      if ((col_here+1) == col_end) {
    freqmsg += (*this_term).term + ": " + termfreqs[(*this_term).term];
    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, const text_t &collection,
                        recptprotolistclass *protos, browsermapclass *browsers, 
                        displayclass &disp, outconvertclass &outconvert, 
                        ostream &textout, ostream &logout) {

  recptproto *collectproto = protos->getrecptproto (collection, logout);
  if (collectproto == NULL) {
    logout << outconvert << "queryaction::search_single_collection: " << collection
       << " 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 (collection, 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"];
  if (!combine_query (args["z"], formattedstring, gsdlhome)) {
    args["q"]=formattedstring;
  }
  format_querystring (formattedstring, args.getintarg("b"));
  set_queryfilter_options (request, formattedstring, args);
  collectproto->filter (collection, request, response, err, logout);
  if (err != noError) {
    outconvertclass text_t2ascii;
    logout << text_t2ascii
       << "queryaction::search_single_collections: call to QueryFilter failed "
       << "for " << collection << " collection (" << get_comerror_string (err) << ")\n";
    return false;
  }

  
  define_query_macros (args, disp, response);

  // save the query if appropriate
  if (!save_search_history(args, response))
    logout << "save failed";

  define_history_macros (disp, args, protos, logout);

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

  // output the results
  bool use_table = is_table_content (formatlistptr);
  bptr->output_section_group (response, args, collection, 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);
  }
}

bool queryaction::save_search_history (cgiargsclass &args, const FilterResponse_t &response) 
{
  if (args["q"]=="") return true; // null query, dont save
  if (args["hs"]=="0") return true; // only save when submit query

  // get userid
  text_t userid = args["z"];

  // the number of docs goes on the front of the query string
  int numdocs= response.numDocs;
  text_t query = text_t(numdocs);
  if (response.isApprox==MoreThan) { // there were more docs found
    query.push_back('+');
  }
  query += "a=q";
  query += "&c="+args["c"];
  query += "&h="+args["h"];
  query += "&t="+args["t"];
  query += "&b="+args["b"];
  query += "&j="+args["j"];
  query += "&n="+args["n"];
  query += "&s="+args["s"];
  query += "&k="+args["k"];
   
  text_t qstring = args["q"];
  text_t formattedquery =cgi_safe(qstring);
  query += "&q="+formattedquery;

  if (set_history_info(userid, query, gsdlhome)) return true;
  else return false;


}