source: trunk/gsdl/src/recpt/collectoraction.cpp@ 1429

/**********************************************************************
 *
 * collectoraction.cpp -- 
 * Copyright (C) 2000  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.
 *
 *********************************************************************/

// note that the collectoraction relies on having direct access to a
// collections configuration file. this breaks the separation between
// receptionist and collection server and so is not suitable (at least
// in its current form) for use when collection servers are separate 
// from the receptionist (e.g. when using the CORBA protocol).

#include "collectoraction.h"
#include "OIDtools.h"
#include "fileutil.h"
#include "cfgread.h"

#if !defined (__WIN32__)
#include <sys/utsname.h>
#include <unistd.h>
#endif

collectoraction::collectoraction () {

  recpt = NULL;
  do_mkcol = false;

  cgiarginfo arg_ainfo;
  arg_ainfo.shortname = "a";
  arg_ainfo.longname = "action";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "collector";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "cp";
  arg_ainfo.longname = "collector page";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "intro";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1fullname";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1dirname";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1contactemail";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1aboutdesc";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1clone";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1clonecol";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1inputdir1";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1inputdir2";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1inputdir3";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  arg_ainfo.shortname = "bc1inputdir4";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = true;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "";
  arg_ainfo.savedarginfo = cgiarginfo::must;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // only set when one of the fields was changed in
  // the "collection info" page
  arg_ainfo.shortname = "bc1infochanged";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::mustnot;
  argsinfo.addarginfo (NULL, arg_ainfo);

  // only set when cfg file is altered from within
  // "configure collection" page
  arg_ainfo.shortname = "bc1cfgchanged";
  arg_ainfo.longname = "collector specific";
  arg_ainfo.multiplechar = false;
  arg_ainfo.defaultstatus = cgiarginfo::weak;
  arg_ainfo.argdefault = "0";
  arg_ainfo.savedarginfo = cgiarginfo::mustnot;
  argsinfo.addarginfo (NULL, arg_ainfo);
}

collectoraction::~collectoraction () {
  delete gsdlosc;
  delete gsdlhomec;
}

bool collectoraction::init (ostream & /*logout*/) {

  // set up GSDLOS and GSDLHOME environment variables
  text_t gsdlos;
#if defined (__WIN32__)
  gsdlos = "windows";
#else
  utsname *buf = new utsname();
  int i = uname (buf);
  if (i == -1) gsdlos = "linux"; // uname failed
  else gsdlos.setcstr (buf->sysname);
  delete buf;
  lc (gsdlos);
#endif
  
  gsdlos = "GSDLOS=" + gsdlos;
  text_t setgsdlhome = "GSDLHOME=" + gsdlhome;

  // these will be cleaned up in the destructor
  gsdlosc = gsdlos.getcstr();
  gsdlhomec = setgsdlhome.getcstr();
  
  putenv (gsdlosc);
  putenv (gsdlhomec);

  return true;
}

bool collectoraction::check_cgiargs (cgiargsinfoclass &/*argsinfo*/, cgiargsclass &args, 
                     ostream &logout) {

  if (args["cp"] != "intro") {
    // authenticate the user if authentication is avaiable
    args["uan"] = 1;
    args["ug"] = "colbuilder";
  }

  if (args["bc1infochanged"] == "1") {

    if (args["bc1dirname"].empty()) {
      // we've just come from the "collection information" page for the 
      // first time so we'll need to create the collection with mkcol.pl
      // and set up bc1dirname - we do this part here instead of in do_action
      // because the bc1dirname argument must be set to its new value before
      // the compressedoptions macros are set.
      args["bc1dirname"] = get_directory_name (args["bc1fullname"]);
      do_mkcol = true;

    } else {
      // "collection information" has been changed after collection was made
      // so we'll need to update the cfg file.
      update_cfgfile_partial (args, logout);
    }
  }

  if (args["bc1cfgchanged"] == "1") {
    // configuration file has been changed from the "configure collection"
    // page. we need to update the file on disk and catch bc1 arguments up
    // with changes.
    update_cfgfile_complete (args, logout);
  }
  
  return true;
}

// update configuration file on disk to match bc1 arguments
void collectoraction::update_cfgfile_partial (cgiargsclass &args, ostream &logout) {

  text_t cfgfile = filename_cat(gsdlhome, "collect", args["bc1dirname"], "etc", "collect.cfg");
  char *cfgfilec = cfgfile.getcstr();

  vector<text_tarray> cfgarray;

  // read in cfg file
  ifstream cfg_in (cfgfilec);
  if (cfg_in) {
    text_tarray cfgline;
    while (read_cfg_line(cfg_in, cfgline) >= 0) {
      if (cfgline.size () >= 2) {
    if (cfgline[0] == "creator") {
      cfgline[1] = args["bc1contactemail"];
    } else if (cfgline[0] == "collectionmeta") {
      if (cfgline[1] == "collectionname") {
        cfgline[2] = args["bc1fullname"];
      } else if (cfgline[1] == "collectionextra") {
        cfgline[2] = carriage_replace (args["bc1aboutdesc"], 0);
      }
    }
      }
      cfgarray.push_back (cfgline);
    }
    cfg_in.close();

    // now write cfg file back out
    ofstream cfg_out (cfgfilec);
    if (cfg_out) {
      // lock the file
      int fd = GSDL_GET_FILEDESC(cfg_out);
      int lock_val = 1;
      GSDL_LOCK_FILE (fd);
      if (lock_val != 0) {
    logout << "Error: Couldn't lock file " << cfgfilec << "\n";
    cfg_out.close();
    
      } else {

    vector<text_tarray>::const_iterator this_line = cfgarray.begin();
    vector<text_tarray>::const_iterator end_line = cfgarray.end();
    while (this_line != end_line) {
      write_cfg_line (cfg_out, *this_line);
      this_line ++;
    }
    GSDL_UNLOCK_FILE (fd);
    cfg_out.close();
      }

    } else {
      logout << "collectoraction::update_cfgfile_partial: unable to open " 
         << cfgfilec << " for output\n";
    }

  } else {
    logout << "collectoraction::update_cfgfile_partial: unable to open " 
       << cfgfilec << " for input\n";
  }
  delete cfgfilec;
}

// replace configuration file on disk with that in the bc1cfgfile argument and 
// catch other bc1 arguments up with those the new cfgfile contains
void collectoraction::update_cfgfile_complete (cgiargsclass &args, ostream &logout) {

  text_t cfgfile = filename_cat(gsdlhome, "collect", args["bc1dirname"], "etc", "collect.cfg");
  char *cfgfilec = cfgfile.getcstr();
  ofstream cfg_out (cfgfilec);
  
  if (cfg_out) {
    // lock the file
    int fd = GSDL_GET_FILEDESC(cfg_out);
    int lock_val = 1;
    GSDL_LOCK_FILE (fd);
    if (lock_val != 0) {
      logout << "Error: Couldn't lock file " << cfgfilec << "\n";
      cfg_out.close();
      
    } else {
      
      outconvertclass text_t2ascii;
      cfg_out << text_t2ascii << args["bc1cfgfile"];
      GSDL_UNLOCK_FILE (fd);
      cfg_out.close();
      
      // now that we've written the file we'll read it back again and
      // update our bc1 arguments
      ifstream cfg_in (cfgfilec);
      if (cfg_in) {
    text_tarray cfgline;
    while (read_cfg_line(cfg_in, cfgline) >= 0) {
      if (cfgline.size () >= 2) {
        if (cfgline[0] == "creator") {
          args["bc1contactemail"] = cfgline[1];
        } else if (cfgline[0] == "collectionmeta") {
          if (cfgline[1] == "collectionname") {
        args["bc1fullname"] = cfgline[2];
          } else if (cfgline[1] == "collectionextra") {
        args["bc1aboutdesc"] = carriage_replace (cfgline[2], 1);
          }
        }
      }
    }
    cfg_in.close();
      } else {
    logout << "collectoraction::update_cfgfile_complete: unable to open " 
           << cfgfilec << " for input\n";
      }
    }
  } else {
    logout << "collectoraction::update_cfgfile_complete: unable to open " 
       << cfgfilec << " for output\n";
  }
  delete cfgfilec;
}

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

// return html for buttons used in collector bar
// color may be "green", "grey", or "yellow"
// type may be:
//   "info" --> "collection information" button
//   "srce" --> "source data" button
//   "conf" --> "configure collection" button
//   "bild" --> "build collection" button
//   "view" --> "view collection" button
// if enabled is true button will be flashy rollover type and 
// will be hyperlinked

text_t collectoraction::get_button (const text_t &thispage, const text_t &color, 
                    const text_t &type, bool enabled) {

  if ((color != "green" && color != "grey" && color != "yellow") ||
      (type != "info" && type != "srce" && type != "conf" && type != "bild" && type != "view"))
    return "";

  text_t prefix = "gc";
  if (color == "grey") prefix = "nc";
  else if (color == "yellow") prefix = "yc";
  
  text_t httpicon = "httpicon" + prefix + type;
  
  if (enabled) {
    text_t gsmacro = "_gsimage_";
    if (thispage == "info" || thispage == "srce" || thispage == "conf") {
      gsmacro = "_gsjimage_";
    }
    return "<td>" + gsmacro + "(_collector:http" + type + "_,_collector:" + httpicon + 
      "of_,_collector:" + httpicon + "on_," + type + ",_collector:text" + type + "_)</td>\n";
  } else {
    return "<td>_icon" + prefix + type + "of_</td>\n";
  }
}

// set the _fullnamemenu_ macro
void collectoraction::set_fullnamemenu (displayclass &disp, cgiargsclass &args, 
                    recptprotolistclass *protos, ostream &logout) {

  if (recpt == NULL) {
    logout << "ERROR (collectoraction::set_fullnamemenu): This action does not contain\n"
       << "       information about any receptionists. The method set_receptionist was\n"
       << "       probably not called from the module which instantiated this action.\n";
    return;
  }

  text_t &currentname = args["bc1clonecol"];
  text_t fullnamemenu;
  bool first = true;

  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;
      comerror_t err;
      (*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();
    FilterResponse_t response;
    text_tset metadata;
    metadata.insert ("collectionname");

    while (collist_here != collist_end) {

      ColInfoResponse_t *cinfo = recpt->get_collectinfo_ptr ((*rprotolist_here).p, *collist_here, logout);
      if (cinfo != NULL) {
        text_t collectionname = *collist_here;
        if (!cinfo->collectionmeta["collectionname"].empty()) {
          // get collection name from the collection cfg file
          collectionname = cinfo->collectionmeta["collectionname"];

        } else if (get_info ("collection", *collist_here, metadata, false, 
                 (*rprotolist_here).p, response, logout)) {
          // get collection name from gdbm file
          collectionname = response.docInfo[0].metadata["collectionname"].values[0];
        }
      
        if (first) fullnamemenu = "<select name=\"bc1clonecol\">\n";
        fullnamemenu += "<option value=\"" + *collist_here;
        fullnamemenu.push_back ('"');
        if (*collist_here == currentname) fullnamemenu += " selected"; 
        fullnamemenu.push_back ('>');
        fullnamemenu += collectionname;

        // check to see if the "collection" is writable
        text_t cfg_fname = filename_cat(gsdlhome, "collect", *collist_here, "etc", "collect.cfg");
        if (!file_writable(cfg_fname)) fullnamemenu += " <b>(write protected)</b>";

        fullnamemenu += "\n";
        
        first = false;
      }
      collist_here ++;
    }
      }
    }
    rprotolist_here ++;
  }
  if (!first) {
    fullnamemenu += "</select>\n";
    disp.setmacro ("fullnamemenu", "collector", fullnamemenu);
  }
}

// set the _cfgfile_ macro
void collectoraction::set_cfgfile (displayclass &disp, const text_t &dirname, ostream &logout) {

  // read in collect.cfg      
  text_t cfgfile = filename_cat(gsdlhome, "collect", dirname, "etc", "collect.cfg");
  char *cfgfilec = cfgfile.getcstr();

#ifdef GSDL_USE_IOS_H
  ifstream cfg_ifs (cfgfilec, ios::in | ios::nocreate);
#else
  ifstream cfg_ifs (cfgfilec, ios::in);
#endif
  
  if (cfg_ifs) {  
    // read in collect.cfg      
    text_t cfgtext;
    char c;
    cfg_ifs.get(c);
    while (!cfg_ifs.eof ()) {
      if (c=='\\') cfgtext.push_back('\\');
      cfgtext.push_back(c);
      cfg_ifs.get(c);
    }
    cfg_ifs.close();
    
    // define it as a macro
    disp.setmacro("cfgfile","collector",cfgtext);

  } else {
    logout << "collectoraction::set_cfgfile: couldn't open configuration file (" 
       << cfgfilec << ") for reading\n";
  }    
  delete cfgfilec;
}

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

  // define_internal_macros sets the following macros:
  // _collectorbar_
  // _pagescriptextra_
  // _fullnamemenu_ -- if displaying the "source data" page
  // _cfgfile_ -- if displaying the "configure collection" page

  text_t &collector_page = args["cp"];

  // set _pagescriptextra_ macro to _cpagescriptextra_
  disp.setmacro ("pagescriptextra", "collector", "_" + collector_page + "scriptextra_");

  // set the collectorbar macro
  text_t collectorbar = "<table border=0 cellspacing=4 cellpadding=0><tr>\n";

  if (collector_page == "new") {
    collectorbar += get_button (collector_page, "green", "info", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "srce", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "conf", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "bild", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "view", false);

  } else if (collector_page == "info") {
    collectorbar += get_button (collector_page, "yellow", "info", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "green", "srce", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "conf", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "bild", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "view", false);
    collectorbar += "</tr><tr><td align=center>_icongreyuparrow_</td><td colspan=8></td>\n";

  } else if (collector_page == "srce") {
    collectorbar += get_button (collector_page, "yellow", "info", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "yellow", "srce", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "green", "conf", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "bild", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "view", false);
    collectorbar += "</tr><tr><td colspan=2></td><td align=center>_icongreyuparrow_</td><td colspan=6></td>\n";

  } else if (collector_page == "conf") {
    collectorbar += get_button (collector_page, "yellow", "info", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "yellow", "srce", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "yellow", "conf", false);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "green", "bild", true);
    collectorbar += "<td>_icongreyarrow_</td>\n";
    collectorbar += get_button (collector_page, "grey", "view", false);
    collectorbar += "</tr><tr><td colspan=4></td><td align=center>_icongreyuparrow_</td><td colspan=4></td>\n";

  } else if (collector_page == "bild") {


  }

  collectorbar += "</tr></table>\n";
  disp.setmacro ("collectorbar", "collector", collectorbar);

  if (collector_page == "srce") set_fullnamemenu (disp, args, protos, logout);
  if (collector_page == "conf") set_cfgfile (disp, args["bc1dirname"], logout);
}

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

  text_t &collector_page = args["cp"];
  text_t error;

  if (do_mkcol) {
    // execute mkcol.pl (do_mkcol is set from within check_cgiargs)
    text_t mkcol_cmd = "perl ";
    mkcol_cmd += filename_cat (gsdlhome, "bin", "script", "mkcol.pl");
    mkcol_cmd += " -creator \"" + args["bc1contactemail"] + "\"";
    mkcol_cmd += " -title \"" + args["bc1fullname"] + "\"";
    mkcol_cmd += " -about \"" + carriage_replace (args["bc1aboutdesc"], 0) + "\" ";
    mkcol_cmd += args["bc1dirname"];
    char *mkcol_cmdc = mkcol_cmd.getcstr();
    system (mkcol_cmdc);
    delete mkcol_cmdc;
    
    // make sure it went ok
    text_t cfgfile = filename_cat (gsdlhome, "collect", args["bc1dirname"], 
                   "etc", "collect.cfg");
    if (!file_writable (cfgfile)) error = "mkcolfail";
  }

  if (collector_page == "bild") {
    // do the work (download, import, build)
    text_t build_cmd = "perl " + filename_cat (gsdlhome, "bin", "script", "build");
    if (!args["bc1inputdir1"].empty()) {
      build_cmd += " -download \"" + args["bc1inputdir1"] + "\"";
    }
    if (!args["bc1inputdir2"].empty()) {
      build_cmd += " -download \"" + args["bc1inputdir2"] + "\"";
    }
    if (!args["bc1inputdir3"].empty()) {
      build_cmd += " -download \"" + args["bc1inputdir3"] + "\"";
    }
    if (!args["bc1inputdir4"].empty()) {
      build_cmd += " -download \"" + args["bc1inputdir4"] + "\"";
    }
    build_cmd.push_back (' ');
    build_cmd += args["bc1dirname"];

#if !defined (__WIN32__)
    // run in background on unix systems
    build_cmd += " &";
#endif
    char *build_cmdc = build_cmd.getcstr();
#if defined (__WIN32__)
    gsdl_system (build_cmdc, logout);
#else
    system (build_cmdc);
#endif
    delete build_cmdc;
  }

  if (error.empty()) {
    textout << outconvert << disp << ("_collector:header_\n")
        << ("_collector:" + collector_page + "content_\n")
        << ("_collector:footer_\n");
  } else {
    textout << outconvert << disp << ("_collector:header_\n")
        << ("_collector:" + error + "content_\n")
        << ("_collector:footer_\n");
  }

  return true;
}

// if sw = 0 replace all carriage returns in intext with the string "\n"
// else replace all occurances of "\n" with a carriage return
text_t collectoraction::carriage_replace (const text_t &intext, int sw) {

  text_t outtext;
  text_t::const_iterator here = intext.begin();
  text_t::const_iterator end = intext.end();
  while (here != end) {
    if (sw == 0) {
      if (*here == '\n') {
    if ((here+1) != end && *(here+1) == '\r') here ++;
    outtext += "\\n";
      } else if (*here == '\r') {
    if ((here+1) != end && *(here+1) == '\n') here ++;
    outtext += "\\n";
      } else {
    outtext.push_back (*here);
      }
    } else if (*here == '\\' && (here+1) != end && *(here+1) == 'n') {
      outtext.push_back ('\n');
      here ++;
    } else {
      outtext.push_back (*here);
    }
    here ++;
  }
  return outtext;
}

// create a short directory name from fullname
text_t collectoraction::get_directory_name (const text_t &fullname) {

  text_t shortname;
  if (fullname.empty()) {
    shortname = "coll";

  } else {
    
    // first make all lowercase and remove any dodgy characters
    // (i.e. anything not [a-z]
    text_t::const_iterator here = fullname.begin();
    text_t::const_iterator end = fullname.end();
    while (here != end) {
      if ((*here >= 'A' && *here <= 'Z') || (*here >= 'a' && *here <= 'z') ||
      (*here == ' ')) {
    if (*here >= 'A' && *here <= 'Z') shortname.push_back (*here+32);
    else if (*here == ' ') {
      while ((*(here+1)) == ' ') here ++;
      shortname.push_back (*here);
    } else shortname.push_back (*here);
      }
      here ++;
    }

    text_tarray words;
    splitchar (shortname.begin(), shortname.end(), ' ', words);
    int num_words = words.size();

    if (num_words == 0) {
      shortname = "coll";

    } else {

      shortname.clear();
      int use_words = (num_words <= 6) ? num_words : 6;
      int substr_len = 6 / use_words;
      
      for (int i = 0; i < use_words; i++) {
    if (words[i].size() < substr_len) shortname += words[i];
    else shortname += substr (words[i].begin(), words[i].begin()+substr_len);
      }
    }
  }

  // check to see if shortname is unique
  text_t fulldirname = filename_cat (gsdlhome, "collect", shortname);
  if (directory_exists (fulldirname)) {
    int version = 0;
    text_t newname;
    do {
      version ++;
      newname = shortname;
      newname.push_back ('v');
      newname.appendint (version);
      fulldirname = filename_cat (gsdlhome, "collect", newname);
    } while (directory_exists (fulldirname));

    shortname = newname;
  }
  
  return shortname;
}