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

/**********************************************************************
 *
 * queryaction.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: queryaction.cpp 337 1999-07-01 22:48:46Z sjboddie $
 *
 *********************************************************************/

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

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

// returns false if formatstring has errors
bool queryaction::parse_formatstring (const text_t &formatstring, text_tarray &formatarray,
                      text_tmap &metamap, text_tarray &metadata, bool &getParents) {

  formatarray.erase (formatarray.begin(), formatarray.end());
  metadata.erase (metadata.begin(), metadata.end());
  getParents = false;

  text_t::const_iterator here = formatstring.begin();
  text_t::const_iterator end = formatstring.end();

  int metacount = 0;
  text_t text;
  while (here != end) {

    if (*here == '\\')
      text.push_back (*(++here));

    else if (*here == '<') {
      if (!text.empty()) formatarray.push_back (text);
      text.clear();
      text_t meta;
      here ++;
      while (*here != '>') {
    if (here == end) return false;
    meta.push_back (*here);
    here ++;
      }
      parse_meta (meta, metacount, formatarray, metadata, getParents, metamap);

    } else 
      text.push_back (*here);

    here ++;
  }
  if (!text.empty()) formatarray.push_back (text);

  return true;
}

void queryaction::get_parent_options (const text_t &instring, text_t &options, 
                      text_t &meta) {

  options.clear();
  meta.clear();
  bool inquotes = false;
  bool foundcolon = false;
  text_t::const_iterator here = instring.begin()+6;
  text_t::const_iterator end = instring.end();
  while (here != end) {
    if (*here == '(') inquotes = true;
    else if (*here == ')') inquotes = false;
    else if (*here == ':' && !inquotes) foundcolon = true;
    else if (foundcolon) meta.push_back (*here);
    else options.push_back (*here);
    here ++;
  }
}

void queryaction::parse_meta (const text_t &meta, int &count, text_tarray &formatarray,
                  text_tarray &metadata, bool &getParents, text_tmap &metamap) {
  
  if (meta == "link" || meta == "/link") formatarray.push_back ("<" + meta + ">");
  else {
    text_t met = meta;

    if (meta.size() > 7 && (substr (meta.begin(), meta.begin()+6) == "parent")) {
      getParents = true;
      text_t ops;
      get_parent_options (meta, ops, met);
    }
    text_tmap::const_iterator it;
    if ((it = metamap.find(met)) != metamap.end())
      formatarray.push_back(meta);
    else {
      metamap[met] = count;
      metadata.push_back (met);
      formatarray.push_back (meta);
      count ++;
    }
  }
}

void queryaction::output_results (const ResultDocInfo_tarray &results, const text_tarray &formatarray,
                  const text_tmap &metamap, displayclass &disp, outconvertclass &outconvert, 
                  ostream &textout) {

  ResultDocInfo_tarray::const_iterator this_doc = results.begin();
  ResultDocInfo_tarray::const_iterator end_doc = results.end();
  text_tmap::const_iterator it;

  textout << "<table cellspacing=4>\n";
  while (this_doc != end_doc) {
    textout << "<tr>\n";

    text_tarray::const_iterator this_format = formatarray.begin();
    text_tarray::const_iterator end_format = formatarray.end();

    while (this_format != end_format) {

      if (*this_format == "<link>")
    textout << outconvert << disp << "<a href=\"_httpdocument_&cl=search&d=" + (*this_doc).OID + "\">";
      else if (*this_format == "</link>") 
    textout << "</a>";
      else if ((it = metamap.find(*this_format)) != metamap.end())
    textout << outconvert << disp 
        << (*this_doc).metadata[(*it).second.getint()].values.back();
      else if ((*this_format).size() > 7 && 
           (substr ((*this_format).begin(), (*this_format).begin()+6) == "parent")) {
    text_t options, meta;
    get_parent_options (*this_format, options, meta);
    if ((it = metamap.find(meta)) != metamap.end()) {
      int metanum = (*it).second.getint();
      if (options.empty()) {
        // no options - we just want the immediate parent
        int num = (*this_doc).metadata[metanum].values.size();
        if (num > 1)
          textout << outconvert << disp
              << (*this_doc).metadata[metanum].values[num-2];
      } else if (options == "top") {
        // want the top parent
        if ((*this_doc).metadata[metanum].values.size() > 1)
          textout << outconvert << disp
              << (*this_doc).metadata[metanum].values[0];
      } else {
        // the 'all' option 
        if (substr (options.begin(), options.begin()+3) != "all")
          // bad format or unknown option
          textout << outconvert << disp << *this_format;
        else {
          text_t::const_iterator fquote = findchar (options.begin(), options.end(), '\'');
          text_t separator = substr (fquote+1, findchar (fquote+1, options.end(), '\''));
          text_tarray::const_iterator here = (*this_doc).metadata[metanum].values.begin();
          // the last metadata value is for the current OID (i.e. it's not a parent)
          text_tarray::const_iterator end = ((*this_doc).metadata[metanum].values.end()) - 1;
          bool first = true;
          while (here != end) {
        if (!first) textout << outconvert << disp << separator;
        textout << outconvert << disp << *here;
        first = false;
        here ++;
          }
        }
      }
    } else {
      // Didn't get any metadata by this name, maybe 
      // it's just plain text that happened to match (oops!!)
      textout << outconvert << disp << *this_format;
    }     
      } else 
    textout << outconvert << disp << *this_format;
      
      this_format ++;
      
    }
    textout << "</tr>\n";
    this_doc ++;
  }

  textout << "</table>\n";
}

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

  // if we have no format string see if the collection server has one
  if (formatstring.empty()) {
    ColInfoResponse_t collectinfo;
    comerror_t err;
    collectproto->get_collectinfo (args["c"], collectinfo, err, logout);
    if (err == noError) {
      text_tmap::const_iterator result = collectinfo.format.find("result");
      if (result != collectinfo.format.end())
    formatstring = (*result).second;
    }
  }
  // if we still don't have a format string use the default
  if (formatstring.empty()) 
    formatstring = "\\<td valign=top nowrap\\><link>_icontext_</link>\\</td\\>\\<td\\><Title>\\</td\\>";

  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 {  

    FilterRequest_t request;
    FilterResponse_t response;
    text_t quotedstring;
    text_tarray formatarray;
    text_tmap metamap;
    parse_formatstring (formatstring, formatarray, metamap, 
            request.fields, request.getParents);

    // do the query
    request.filterResultOptions = FROID | FRmetadata | FRtermFreq;
    //    request.fields.push_back ("Title");
    //    request.fields.push_back ("Creator");
    //    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 (response.docInfo, formatarray, metamap, disp, outconvert, textout);

    
    // output the footer
    textout << outconvert << disp << "_query:footer_";
  }
  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, 
                       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);
  }
}