psfaCGI.cpp

gehe zur Dokumentation dieser Datei

// Copyright (C) 2004 Bernhard Assmann <bernie@tuxomania.net>
//  
// 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//  

#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>
#include <cstdlib>
#include <sstream>

#include <cgicc/Cgicc.h>

#include "psfa/DbReadDriverMySql.hpp"
#include "psfa/Config.hpp"
#include "psfa/Helper.hpp"

#include "Demo-Template.hpp"


void
setUpPsfa() 
{
  using psfa::sVec;
  using psfa::Config;
  using psfahelper::pathIsReadable;

  sVec psfaConfigs;
  psfaConfigs.reserve( 3 );
  const char* env = getenv("PSFA_CONFIG");
  if ( env ) {
    psfaConfigs.push_back( env );
    delete env;
  }
  env = std::getenv("HOME");
  if ( env ) {
    std::string h( env );
    h += "/.psfa/psfa_conf.xml";
    psfaConfigs.push_back( h );
    delete env;
  }
  psfaConfigs.push_back( "/etc/psfa_conf.xml" );

  Config* conf = Config::getConfig();
  sVec::iterator i;
  sVec::iterator iEnd = psfaConfigs.end();
  for( i = psfaConfigs.begin(); i != iEnd; ++i ) {
    if( pathIsReadable( *i ) ) {
      conf->parseConfig( *i );
    }
  }
  return;
}



void
getOptions( psfa::sVec& vec, std::string& options, std::string def ) 
{
  std::ostringstream opts;
  
  opts << "<option value=\""
       << def
       << "\">"
       << def
       << "</option>\n";
  psfa::sVec::iterator i;
  psfa::sVec::iterator iEnd = vec.end();
  for( i = vec.begin(); i != iEnd; ++i ) {
    opts << "<option value=\""
    << *i
    << "\">"
    << *i
    << "</option>\n";
  }
  options = opts.str();
  return;
}


void
printVec( psfa::sVec& vec, std::ostringstream& stream ) 
{
  using psfa::sVec;
  
  stream << "<table>\n";
  sVec::iterator i;
  sVec::iterator iEnd = vec.end();
  for( i = vec.begin(); i != iEnd; ++i ) {
    stream << "<tr><td>"
      << *i
      << "</td></tr>\n";
  }
  stream << "</table>\n";
}



int main(int, char ** ) 
{
  using std::cout;
  using std::endl;
  using std::string;
  using std::ostringstream;
  using std::vector;
  using psfa::DbReadDriver;
  using psfa::DbReadDriverMySql;
  using psfa::SearchData;
  using psfa::sVec;
  using psfa::Config;
  using psfa::IndexData_SP;
  using psfahelper::pathIsReadable;
  using psfahelper::splitString;
  using cgicc::Cgicc;
  using cgicc::CgiEnvironment;
  using cgicc::FormEntry;
  using cgicc::form_iterator;

  setUpPsfa();
  DbReadDriver *read = new DbReadDriverMySql;
    
  sVec pools;
  sVec result;
  string options("");
  string tmp;
  string::size_type tplPos;

  read->getPools( pools );
  psfa::sVec::iterator p;
  psfa::sVec::iterator pEnd = pools.end();
  for( p = pools.begin(); p != pEnd; ++p ) {
    read->getSearchTags( *p, result );
    getOptions( result, options, "Such-Tags" );
    tmp = "PSFA--option_" + *p + "_search";
    tplPos = searchForm.find( tmp );
    if( tplPos < string::npos ) {
      searchForm.replace( tplPos, tmp.size(), options );
    }
    options = "";
    result.clear();

    read->getKontextTags( *p, result );
    getOptions( result, options, "Kontext-Tags" );
    tmp = "PSFA--option_" + *p + "_kontext";
    tplPos = searchForm.find( tmp );
    if( tplPos < string::npos ) {
      searchForm.replace( tplPos, tmp.size(), options );
    }
    options = "";
    result.clear();

    read->getUnits( *p, result );
    getOptions( result, options, "Einheiten" );
    tmp = "PSFA--option_" + *p + "_unit";
    tplPos = searchForm.find( tmp );
    if( tplPos < string::npos ) {
      searchForm.replace( tplPos, tmp.size(), options );
    }
    options = "";
    result.clear();

    read->getFiles( *p, result );
    getOptions( result, options, "Dateien" );
    tmp = "PSFA--option_" + *p + "_file";
    tplPos = searchForm.find( tmp );
    if( tplPos < string::npos ) {
      searchForm.replace( tplPos, tmp.size(), options );
    }
    options = "";
    result.clear();

    read->getUniqueContent( *p, result );
    getOptions( result, options, "Inhalte" );
    tmp = "PSFA--option_" + *p + "_content";
    tplPos = searchForm.find( tmp );
    if( tplPos < string::npos ) {
      searchForm.replace( tplPos, tmp.size(), options );
    }
    options = "";
    result.clear();
  }

  string pool("");
  string action("");

  Cgicc cgi;
  const vector< FormEntry > vFormEntries = cgi.getElements();
  vector< FormEntry >::const_iterator f;
  vector< FormEntry >::const_iterator fEnd = vFormEntries.end();
  for ( f = vFormEntries.begin(); f != fEnd; ++f ) {
    sVec formSubmit;
    splitString( f->getName(), formSubmit, "_" );
    if( formSubmit[0] == "submit" ) {
      pool = formSubmit[1];
      action = formSubmit[2];
    }
  }

  int resCount = 0;
  ostringstream resCountStream;
  ostringstream resStream;
  
  if( action == "showPools" ) {
    printVec( pools, resStream );
    resCount = pools.size();
  }
  else if( action == "tag" ) {
    read->getSearchTags( pool, result );
    printVec( result, resStream );
    resCount = result.size();
  }
  else if( action == "kontext" ) {
    read->getKontextTags( pool, result );
    printVec( result, resStream );
    resCount = result.size();
  }
  else if( action == "unit" ) {
    read->getUnits( pool, result );
    printVec( result, resStream );
    resCount = result.size();
  }
  else if( action == "file" ) {
    read->getFiles( pool, result );
    printVec( result, resStream );
    resCount = result.size();
  }
  else if( action == "content" ) {
    read->getUniqueContent( pool, result );
    printVec( result, resStream );
    resCount = result.size();
  }
  else if( action == "entry" ) {
    SearchData search;
    tmp = "check_" + pool + "_att";
    if( cgi.queryCheckbox( tmp ) ) {
      search.incAtts = true;
    }
    tmp = "check_" + pool + "_pos";
    if( cgi.queryCheckbox( tmp ) ) {
      search.incPosData = true;
    }

    tmp = "select_" + pool + "_search";
    form_iterator fV = cgi[tmp];
    if( fV->getValue() != "Such-Tags" ) {
      search.searchTag = fV->getValue();
    }
    tmp = "select_" + pool + "_kontext";
    fV = cgi.getElement(tmp);
    if( fV->getValue() != "Kontext-Tags" ) {
      search.kontextTag = fV->getValue();
    }
    tmp = "select_" + pool + "_unit";
    fV = cgi.getElement(tmp);
    if( fV->getValue() != "Einheiten" ) {
      search.unit = fV->getValue();
    }
    tmp = "select_" + pool + "_content";
    fV = cgi.getElement(tmp);
    if( fV->getValue() != "Inhalte" ) {
      search.content = fV->getValue();
    }
    
    typedef std::vector< IndexData_SP > iVec;
    iVec entries;
    IndexData_SP data;
    
    resCount = read->getEntries( pool, search, entries );
    resStream << "<table>\n";
    iVec::iterator i;
    iVec::iterator iEnd = entries.end();
    for( i = entries.begin(); i != iEnd; ++i ) {
      data = *i;
      resStream << "<tr><td>&nbsp;</td><td>&nbsp;</td></tr>\n"
      << "<tr>\n"
      << "<td>Such-Tag</td>"
      << "<td>"
      << data->tag
      << "</td>"
      << "</tr>\n";
      if( search.incAtts ) {
   if( !data->attributes.empty() ) {
     resStream << "<tr>\n"
          << "<td>Attribute</td>"
          << "<td>\n"
          << "<table>\n"
          << "<tr><td>Name</td><td>Wert</td></tr>";
     psfa::AttMap::iterator a;
     psfa::AttMap::iterator aEnd = data->attributes.end();
     for( a = data->attributes.begin(); a != aEnd; ++a ) {
       resStream << "<tr><td>"
            << a->first
            << "</td><td>"
            << a->second
            << "</td></tr>";
     }
     resStream << "</table>\n"
          << "</td>\n"
          << "</tr>\n";
   }
      }
      resStream << "<tr>\n"
      << "<td>Inhalt</td>"
      << "<td>"
      << data->content
      << "</td>"
      << "</tr>\n"
      << "<tr>\n"
      << "<td>Kontext</td>"
      << "<td>"
      << data->kontext
      << "</td>"
      << "</tr>\n"
      << "<tr>\n"
      << "<td>Einheit</td>"
      << "<td>"
      << data->unit
      << "</td>"
      << "</tr>\n"
      << "<tr>\n"
      << "<td>Datei</td>"
      << "<td>"
      << data->file
      << "</td>"
      << "</tr>\n";
      if( search.incPosData ) {
   resStream << "<tr>\n"
        << "<td>Start-Zeile</td>"
        << "<td>"
        << data->lineStart
        << "</td>"
        << "</tr>\n"
        << "<tr>\n"
        << "<td>Start-Kolumne</td>"
        << "<td>"
        << data->columnStart
        << "</td>"
        << "</tr>\n"
        << "<tr>\n"
        << "<td>Stop-Zeile</td>"
        << "<td>"
        << data->lineStop
        << "</td>"
        << "</tr>\n"
        << "<tr>\n"
        << "<td>Stop-Kolumne</td>"
        << "<td>"
        << data->columnStop
        << "</td>"
        << "</tr>\n"
        << "<tr>\n"
        << "<td>Start-Position</td>"
        << "<td>"
        << data->posStart
        << "</td>"
        << "</tr>\n"
        << "<tr>\n"
        << "<td>Stop-Position</td>"
        << "<td>"
        << data->posEnd
        << "</td>"
        << "</tr>\n";
      }
    }
    resStream << "</table>\n";
  }
  
  resCountStream << resCount;
  tmp = "PSFA--count";
  tplPos = searchForm.find( tmp );
  if( tplPos < string::npos ) {
    searchForm.replace( tplPos, tmp.size(), resCountStream.str() );
  }
    
  tmp = "PSFA--result";
  tplPos = searchForm.find( tmp );
  if( tplPos < string::npos ) {
    searchForm.replace( tplPos, tmp.size(), resStream.str() );
  }
  
  cout << "Content-Type: text/html" << endl
       << endl
       << searchForm 
       << endl;

  delete read;
  return 0;
}
  

---