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

/**********************************************************************
 *
 * queryaction.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: queryaction.cpp 295 1999-06-26 01:10:18Z rjmcnab $
 *
 *********************************************************************/

/*
   $Log$
   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"

queryaction::queryaction () {
  // 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);

  // "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);

  // "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);

  // "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);

  // "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);

  // "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);
}

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 < 0) {
    logout << "Warning: \"m\" argument less than 0 (" << 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 < 0) {
    logout << "Warning: \"o\" argument less than 0 (" << 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*/, response_t &response,
                     text_t &response_data, ostream &/*logout*/) {
  response = content;
  response_data = "text/html";
}

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

  // define_internal_macros doesn't set anything for this action. The following
  // macros are set later though in define_query_macros (they can't be set until 
  // the query has been done).

  // _freqmsg_      the term frequency string

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

  // _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_
  
}

// sets the selection box macros _hselection_, _jselection_, and _nselection_.
// each option will need an _optionxoption_ macro (i.e. an _hselection_ macro 
// with options stx and ptx will need _optionhstx_ and _optionhptx_ macros)
void queryaction::set_option_macro (const text_t &macroname, text_t current_value,
                    const FilterOption_t &option, displayclass &disp) {
  
  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 += ">_option" + macroname + *thisvalue + "_\n";
    thisvalue ++;
  }
  macrovalue += "</select>\n";
  disp.setmacro (macroname + "selection", "Global", macrovalue);
}

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

  // define_external_macros sets the following macros:

  // some or all of these may not be required to be set
  // _hselection_  the selection box for the main part of the index
  // _jselection_  the selection box for the subcollection part of the index
  // _nselection_  the selection box for the language part of the index

  
  // can't do anything if collectproto is null (i.e. no collection was specified)
  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_ (Index)
    it = response.filterOptions.find ("Index");
      if (it != end) set_option_macro ("h", args["h"], (*it).second, disp);

    // _jselection_ (Subcollection)
    it = response.filterOptions.find ("Subcollection");
      if (it != end) set_option_macro ("j", args["j"], (*it).second, disp);

    // _nselection_ (Language)
    it = response.filterOptions.find ("Language");
      if (it != end) set_option_macro ("n", args["n"], (*it).second, disp);
  }
}

bool queryaction::do_action (cgiargsclass &args, recptproto *collectproto,
                 displayclass &disp, outconvertclass &outconvert, 
                 ostream &textout, ostream &logout) {

  if (collectproto == NULL) {
    logout << "queryaction::do_action called with NULL collectproto\n";
    textout << outconvert << disp << "_query:header_\n" 
        << "Error: Attempt to do query without setting collection\n"
        << "_query:footer_\n";
  } else {  

    text_t quotedstring;
    FilterResponse_t response;
    
    // do the query
    FilterRequest_t request;
    request.filterResultOptions = FROID | FRmetadata | FRtermFreq;
    request.fields.push_back ("Title");
    request.getParents = true;
    if (!do_query (request, args, collectproto, quotedstring, response, logout))
      return false;
    
    // set macros 
    define_query_macros (args, disp, response, quotedstring);
    
    // output the header
    textout << outconvert << disp << "_query:header_\n_query:content_";
    
    // output results 
    ResultDocInfo_tarray::const_iterator this_doc = response.docInfo.begin();
    ResultDocInfo_tarray::const_iterator end_doc = response.docInfo.end();
    
    textout << "<table cellspacing=4>\n";
    while (this_doc != end_doc) {

      text_t link = "<a href=\"_httpdocument_&cl=search&d=" + (*this_doc).OID + "\">";

      text_t title;
      text_tarray::const_iterator this_title = (*this_doc).metadata[0].values.begin();
      text_tarray::const_iterator end_title = (*this_doc).metadata[0].values.end();
      while (this_title != end_title) {
    if ((this_title + 1) == end_title) 
      title += link + *this_title + "</a>";
    else 
      title += *this_title + ": ";
    this_title ++;
      }
      
      textout << outconvert << disp << "<tr><td valign=top nowrap>" << link 
          << "_icontext_</a></td><td>" << title << "</td></tr>\n";
      
      this_doc ++;
    }
    textout << "</table>\n";
    
    // output the footer
    textout << outconvert << disp << "_query:footer_";
  }
  return true;
}
  
// set_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, 
                       const text_t &quotedstring) {

  int numdocs = response.numDocs;
  int arg_m = args.getintarg("m");
  if (numdocs > arg_m)
    numdocs = arg_m;

  // 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 ("quotedquery", "query", quotedstring);
  disp.setmacro ("freqmsg", "query", freqmsg);


  // set up _resultline_ macro
  text_t resline;

  // can't use isApprox here as it will be false as long 
  // as numDocs < MAXDOCS (currently 500). If arg_m is less
  // than MAXDOCS numDocs can be greater than arg_m while
  // isApprox is false.
  if (response.numDocs > numdocs || 
      ((response.numDocs == numdocs) && response.isApprox))
    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");

  // 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);
  }
}