webpac-proto/search/Search.cgi

#!/usr/bin/perl -w

#*****************************************************************************
#       Copyright (C) 1993-2000, FS Consulting Inc. All rights reserved      *
#                                                                            *
#                                                                            *
#  This notice is intended as a precaution against inadvertent publication   *
#  and does not constitute an admission or acknowledgement that publication  *
#  has occurred or constitute a waiver of confidentiality.                   *
#                                                                            *
#  This software is the proprietary and confidential property                *
#  of FS Consulting, Inc.                                                    *
#*****************************************************************************

#print "Content-type: text/plain\n\n";

#use Data::Dumper;

#--------------------------------------------------------------------------
#
# Author: Francois Schiettecatte (FS Consulting, Inc.)
# Creation Date: 8/9/96


#--------------------------------------------------------------------------
#
# Description:
#
# This script implements the search interface into the search engine. We
# interface with the search engine using the Direct protocol.
#


#--------------------------------------------------------------------------
#
# Modification Log
#
# Date: 
# Author:  
# Organization: 
# Email: 
# Description: 
#
#
# Date: 8/9/96
# Author: Francois Schiettecatte
# Organization: FS Consulting, Inc.
# Email: francois@fsconsult.com
# Description: First cut.


#--------------------------------------------------------------------------
#
# CGI-BIN mode usage
#

# We use the following environment variables from the cgi-bin environment:
#
#       $PATH_INFO                      - action requested
#       $QUERY_STRING           - contains the query
#       $REMOTE_USER            - user account name
#       $REQUEST_METHOD         - request method
#       $SCRIPT_NAME            - script name
#


# We create the following variables as we go along,
# these will both be empty if this is a guest user
#
#       $main::RemoteUser                                       - contains the remote user name
#       $main::UserAccountDirectoryPath         - contains the path name to the user account directory
#       $main::UserSettingsFilePath                     - contains the path name to the user information file
#


# User directory structure
#
# /AccountName                                                          (user directory)
#


#--------------------------------------------------------------------------
#
# Pragmatic modules
#

use strict;


#--------------------------------------------------------------------------
#
# Set the default configuration directories, files & parameters
#


# Root directory path
$main::RootDirectoryPath = (($main::Index = rindex($0, "/")) >= 0) ? substr($0, 0, $main::Index) : ".";

# Program name
$main::ProgramName = (($main::Index = rindex($0, "/")) >= 0) ? substr($0, $main::Index + 1) : $0;

# Program base name
$main::ProgramBaseName = (($main::Index = rindex($main::ProgramName, ".")) >= 0) ? substr($main::ProgramName, 0, $main::Index) : $main::ProgramName;


# Log directory path 
$main::LogDirectoryPath = $main::RootDirectoryPath . "/logs";


# Configuration file path
$main::ConfigurationFilePath = $main::RootDirectoryPath .  "/" . $main::ProgramBaseName . ".cf";

# Log file path
$main::LogFilePath = $main::LogDirectoryPath .  "/" . lc($main::ProgramBaseName) . ".log";


# Log file roll-over
#$main::LogFileRollOver = 0;


#--------------------------------------------------------------------------
#
# Required packages
#

# Load the libraries
push @INC, $main::RootDirectoryPath;
require "Library.pl";


# Load the MPS Information Server library
use MPS;

#--------------------------------------------------------------------------
#
# Environment variables
#

# Set up the environment so that we can find the external applications we need
$ENV{'PATH'} = "/bin:/usr/bin:/sbin:/usr/sbin:/usr/ucb:/usr/etc";
$ENV{'LD_LIBRARY_PATH'} = "/usr/lib";


#--------------------------------------------------------------------------
#
# Global
#

# Configuration global (used to store the information read in from the configuration file)
undef(%main::ConfigurationData);


# Database descriptions global (used to store the information read in from the database description file)
undef(%main::DatabaseDescriptions);
undef(%main::DatabaseSort);


# Database Filters global (used to store the information read in from the database description file)
undef(%main::DatabaseFilters);


# Global flags which are set after sending the html header and footer
$main::HeaderSent = 0;
$main::FooterSent = 0;

# Form data global (this is used to store the information decoded from a form)
undef(%main::FormData);


# User account information
undef($main::UserSettingsFilePath);
undef($main::UserAccountDirectoryPath);
undef($main::RemoteUser);


$main::MPSSession = 0;

#--------------------------------------------------------------------------
#
# Configuration Constants
#


# read configuration fields
require "config.pm";

# List of required configuration settings
@main::RequiredSettings = (
        'html-directory', 
        'logs-directory', 
        'image-base-path', 
        'database-directory',
        'configuration-directory'
);


$main::DatabaseName = "database-name";
$main::DatabaseFiltersPackage = "database-filters-package";
$main::DatabaseDocumentFilter = "database-document-filter";
$main::DatabaseSummaryFilter = "database-summary-filter";
$main::DatabaseRelevanceFeedbackFilter = "database-relevance-feedback-filter";


#--------------------------------------------------------------------------
#
# Application Constants
#


# XML file name extension
$main::XMLFileNameExtension = ".xml";


# User Settings file
$main::UserSettingsFileName = "UserSettings";

# Saved Search file preamble
$main::SavedSearchFileNamePrefix = "SavedSearch";

# Search history file preamble
$main::SearchHistoryFileNamePrefix = "SearchHistory";

# Document Folder file preamble
$main::DocumentFolderFileNamePrefix = "DocumentFolder";


# Query report item name and mime type
$main::QueryReportItemName = "document";
$main::QueryReportMimeType = "application/x-wais-report";


# Array of mime type names, we use this to map
# mime types to mime type names (which are more readable)
%main::MimeTypeNames = (
        'text/plain',   'Text',
        'text/html',    'HTML',
        'text/http',    'HTML',
        'text/http',    'HTML',
        'image/gif',    'GIF Image',
        'image/tif',    'TIF Image',
        'image/jpeg',   'JPEG Image',
        'image/jfif',   'JPEG Image',
);


# Array of mime types that we can resonably use for relevance feedback
%main::RFMimeTypes = (
        'text/plain',   'text/plain',
        'text/html',    'text/html',
        'text/http',    'text/http',
);


# Array of mime types that are in HTML
%main::HtmlMimeTypes = (
        'text/html',    'text/html',
        'text/http',    'text/http',
);


# DbP: replaced by NormalSearchFieldNames and AdvancedSearchFieldNames
# Search fields
#@main::SearchFieldNames = ( 
#       '200-ae', 
#       '700,701,702,710,711',
#       '610'
#);

# DbP: this variable will be filled using MPS::GetDatabaseFieldInfo
%main::SearchFieldDescriptions = (
#       'title',                'Title',
#       'abstract',             'Abstract',
#       'author',               'Author',
#       'journal',              'Journal',
);


# Date list
@main::PastDate = ( 
        'Week', 
        'Month', 
        '3 Months', 
        '6 Months', 
        '9 Months', 
        'Year'
);

# Default maximum number of documents
$main::DefaultMaxDoc = 50;

# Maximum docs list used for the search form pull-down
@main::MaxDocs = ( '10', '25', '50', '100', '250', '500', '750');


# Default maximum search history
$main::DefaultMaxSearchHistory = 15;


# Summary type for the settings form pull-down
%main::SummaryTypes = (
        'none',                 'None',
        'keyword',              'Keywords in Context',
        'default',              'Default summary',
);


# Summary length for the settings form pull-down
@main::SummaryLengths = ( '20', '40', '60', '80', '100', '120' );

# Default summary length
$main::DefaultSummaryLength = 40;

# Default summary type
$main::DefaultSummaryType = "default";


# Similar documents for the settings form pull-down
@main::SimilarDocuments = ( '1', '3', '5', '10' );

# Default similar document
$main::DefaultSimilarDocument = 5;

# Token span on either side of the summary keyword
$main::SummaryKeywordSpan = 9;


# Delivery format
%main::DeliveryFormats = (
        'text/plain',                           'Plain text',
        'text/html',                            'HTML',
);

# Delivery methods
%main::DeliveryMethods = (
        'message',                                      'Email message',
        'attachement',                          'Email attachement',
);


# Search frequency
@main::SearchFrequencies = (
        'Daily',
        'Weekly',
        'Monthly'
);


# Default maximum visible URL length
$main::DefaultMaxVisibleUrlLength = 80;


#--------------------------------------------------------------------------
#
#       Function:       vSendHTMLHeader()
#
#       Purpose:        This function send the HTML header 
#
#       Called by:      
#
#       Parameters:     $Title                  HTML page title
#                               $JavaScript             JavaScript to send
#
#       Global Variables:       $main::HeaderSent
#
#       Returns:        void
#
sub vSendHTMLHeader {

        my ($Title, $JavaScript) = @_;
        

        # Bail if we are not running as a CGI-BIN script
        if ( ! $ENV{'GATEWAY_INTERFACE'} ) {
                return;
        }

        # Bail if we have already sent the header
        if ( $main::HeaderSent ) {
                return;
        }


        # Send the CGI-BIN response header
        print("Content-type: text/html\n\n");
        
        # Put out the html document header 
        printf("<HTML>\n<HEAD>\n<TITLE>\n%s\n</TITLE>\n", defined($Title) ? $Title : "FS Consulting - MPS Direct Search Interface");
        if ( defined($JavaScript) ) {
                print("$JavaScript\n");
        }
        print '<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-2">';
        print '<link rel="STYLESHEET" type="text/css" href="'.$main::ConfigurationData{'image-base-path'}.'/stil.css">';
        print("</HEAD>\n<BODY BGCOLOR=\"ffffe8\">\n");


        # Send the header snippet file
        &vPrintFileContent($main::ConfigurationData{'html-header-snippet-file'});
        

        # Send the banner
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
#       print("<TR><TD VALIGN=TOP ALIGN=RIGHT> <A HREF=\"/\" OnMouseOver=\"self.status='Return Home'; return true\"><IMG SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'banner'}\" ALT=\"Return Home\" BORDER=0></A> </TD></TR>\n"); 

        print("<TR><TD VALIGN=TOP ALIGN=RIGHT> <A HREF=\"/\" OnMouseOver=\"self.status='Return Home'; return true\"><H3>Katalozi knji¾nica Filozofskog fakulteta</H3> </A> </TD></TR>\n");

        print("</TABLE>\n");
                

        # Set the flag saying that the header has been sent
        $main::HeaderSent = 1;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vSendHTMLFooter()
#
#       Purpose:        This function send the HTML footer 
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       $main::FooterSent
#
#       Returns:        void
#
sub vSendHTMLFooter {


        # Bail if we are not running as a CGI-BIN script
        if ( ! $ENV{'GATEWAY_INTERFACE'} ) {
                return;
        }
        
        # Bail if we have already sent the footer
        if ( $main::FooterSent ) {
                return;
        }


        # Send the footer snippet file
        &vPrintFileContent($main::ConfigurationData{'html-footer-snippet-file'});


        # Send the end of body tag and end of HTML tag
        print("</BODY>\n</HTML>\n");


        # Set the flag saying that the footer has been sent
        $main::FooterSent = 1;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vSendMenuBar()
#
#       Purpose:        This function send the mneu bar 
#
#       Called by:      
#
#       Parameters:     %MenuBar                menu bar exclusion hash table
#
#       Global Variables:       
#
#       Returns:        void
#
sub vSendMenuBar {

        my (%MenuBar) = @_;
        
        my (%Value, $Value, $ValueEntry);


        # Start the table
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

        # Start the menu bar cell
        print("<TR><TD VALIGN=CENTER ALIGN=CENTER>\n");

        # Start the form
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
        

        # List the hidden fields
        %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
        foreach $Value ( keys(%Value) ) {
                foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
                        print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
                }
        }

        my $DISABLED;

        $DISABLED = ( %MenuBar && defined($MenuBar{'GetSearch'}) ) ? "DISABLED" : "";
        print("<INPUT NAME=\"GetSearch\" TYPE=SUBMIT VALUE=\"Pretra¾ivanje\" $DISABLED class=\"navigacija${DISABLED}\">");

        if ( defined($main::RemoteUser) ) {
                $DISABLED = ( %MenuBar && defined($MenuBar{'ListSearchHistory'}) ) ? "DISABLED" : "";
                print"<INPUT NAME=\"ListSearchHistory\" TYPE=SUBMIT VALUE=\"Prija¹nja pretra¾ivanja\" $DISABLED class=\"navigacija${DISABLED}\">";

                $DISABLED = ( %MenuBar && defined($MenuBar{'ListSavedSearch'}) ) ? "DISABLED" : "";
                print"<INPUT NAME=\"ListSavedSearch\" TYPE=SUBMIT VALUE=\"Saèuvani upiti\" $DISABLED class=\"navigacija${DISABLED}\">";

                $DISABLED = ( %MenuBar && defined($MenuBar{'ListFolder'}) ) ? "DISABLED" : "";
                print"<INPUT NAME=\"ListFolder\" TYPE=SUBMIT VALUE=\"Korisnièki folderi\" $DISABLED class=\"navigacija${DISABLED}\">";
        
                $DISABLED = ( %MenuBar && defined($MenuBar{'GetUserSettings'}) ) ? "DISABLED" : "";
                print"<INPUT NAME=\"GetUserSettings\" TYPE=SUBMIT VALUE=\"Korisnièke postavke\" $DISABLED class=\"navigacija${DISABLED}\">";
        }


        print("</FORM>\n");

        # Close off the menu bar cell
        print("</TD></TR>\n");

        print("</TABLE>\n");

        
        return;
}


#--------------------------------------------------------------------------
#
#       Function:       vHandleError()
#
#       Purpose:        This function handles any errors messages that need to be
#                               reported when an error occurs
#
#                               This error handler also displays the header if needed
#
#       Called by:      
#
#       Parameters:             $Header         header
#                                       $Message        message
#
#       Global Variables:       
#
#       Returns:        void
#
sub vHandleError {

        my ($Header, $Message) = @_;

        my ($Package, $FileName, $Line);


        # Make sure we send the header
        &vSendHTMLHeader("Error", undef);


        printf("<H3> %s: </H3>\n", defined($Header) ? $Header : "No header supplied");
        printf("<H3><CENTER> %s. </CENTER></H3>\n", defined($Message) ? $Message : "No error message supplied");
        print("<P>\n");
        if ( defined($main::ConfigurationData{'site-admin-url'}) ) {
                print("<CENTER> Please <A HREF=\"$main::ConfigurationData{'site-admin-url'}\"> contact the administrator </A> of this system to correct the problem. </CENTER>\n");
        }
        else {
                print("<CENTER> Please contact the administrator of this system to correct the problem. </CENTER>\n");
        }
        print("<P><HR WIDTH=50%><P>\n");


        # Send package information
#       ($Package, $FileName, $Line) = caller;
#       print("Package = [$Package], FileName = [$FileName], Line = [$Line] <BR>\n");

        return;
}


#--------------------------------------------------------------------------
#
#       Function:       bCheckConfiguration()
#
#       Purpose:        This function checks that the configuration settings
#                               specified are correct and that any directory paths and
#                               files specified are there and can be accessed.
#
#                               We check both required settings and optional setting if
#                               they have been set.
#
#                               An error here should be considered fatal.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData
#
#       Returns:        Boolean status
#
sub bCheckConfiguration {

        my ($Value, $Status);
        

        # Init the status
        $Status = 1;


        # Check 'user-accounts-directory' (optional)
        if ( defined($main::ConfigurationData{'user-accounts-directory'}) ) {
                
                $main::ConfigurationData{'user-accounts-directory'} = &sCleanSetting('user-accounts-directory', $main::ConfigurationData{'user-accounts-directory'}, $main::RootDirectoryPath);
                $Value = $main::ConfigurationData{'user-accounts-directory'};
                
                # Check that the directory exists
                if ( ! (-d $Value) ) {
                        &vLog("Error - configuration setting: 'user-accounts-directory', directory: '$Value' does not exist.\n");
                        $Status = 0;
                }
                else {
                
                        # The directory exists, now check that it can be accessed
                        if ( ! ((-r $Value) && (-w $Value) && (-x $Value)) ) {
                                &vLog("Error - configuration setting: 'user-accounts-directory', directory: '$Value' cannot be accessed.\n");
                                $Status = 0;
                        }
                }
        }


        # Check 'database-description-file' (optional)
        if ( defined($main::ConfigurationData{'database-description-file'}) ) {

                $main::ConfigurationData{'database-description-file'} = &sCleanSetting('database-description-file', $main::ConfigurationData{'database-description-file'}, $main::RootDirectoryPath);
                $Value = $main::ConfigurationData{'database-description-file'};
                
                # Check that the file exists
                if ( ! ((-f $Value) && (-r $Value)) ) {
                        &vLog("Error - configuration setting: 'database-description-file', file: '$Value' does not exist.\n");
                        $Status = 0;
                }
        }


        # Check 'allow-summary-displays' (optional)
        if ( defined($main::ConfigurationData{'allow-summary-displays'}) ) {

                # Clean the setting and convert to lower case
                $main::ConfigurationData{'allow-summary-displays'} = &sCleanSetting('allow-summary-displays', $main::ConfigurationData{'allow-summary-displays'});
                $main::ConfigurationData{'allow-summary-displays'} = lc($main::ConfigurationData{'allow-summary-displays'});
                
                # Check that the setting is valid
                if ( ($main::ConfigurationData{'allow-summary-displays'} ne "yes")  && ($main::ConfigurationData{'allow-summary-displays'} ne "no")) {
                        &vLog("Warning - configuration setting: 'allow-summary-displays', setting not recognized: $main::ConfigurationData{'allow-summary-displays'}.\n");
                }               
        }


        # Check 'allow-similiar-search' (optional)
        if ( defined($main::ConfigurationData{'allow-similiar-search'}) ) {

                # Clean the setting and convert to lower case
                $main::ConfigurationData{'allow-similiar-search'} = &sCleanSetting('allow-similiar-search', $main::ConfigurationData{'allow-similiar-search'});
                $main::ConfigurationData{'allow-similiar-search'} = lc($main::ConfigurationData{'allow-similiar-search'});
                
                # Check that the setting is valid
                if ( ($main::ConfigurationData{'allow-similiar-search'} ne "yes")  && ($main::ConfigurationData{'allow-similiar-search'} ne "no")) {
                        &vLog("Warning - configuration setting: 'allow-similiar-search', setting not recognized: $main::ConfigurationData{'allow-similiar-search'}.\n");
                }               
        }


        # Check 'allow-regular-searches' (optional)
        if ( defined($main::ConfigurationData{'allow-regular-searches'}) ) {

                # Clean the setting and convert to lower case
                $main::ConfigurationData{'allow-regular-searches'} = &sCleanSetting('allow-regular-searches', $main::ConfigurationData{'allow-regular-searches'});
                $main::ConfigurationData{'allow-regular-searches'} = lc($main::ConfigurationData{'allow-regular-searches'});
                
                # Check that the setting is valid
                if ( ($main::ConfigurationData{'allow-regular-searches'} ne "yes")  && ($main::ConfigurationData{'allow-regular-searches'} ne "no")) {
                        &vLog("Warning - configuration setting: 'allow-regular-searches', setting not recognized: $main::ConfigurationData{'allow-regular-searches'}.\n");
                }               
        }


        # Check 'deliver-empty-results-from-regular-search' (optional)
        if ( defined($main::ConfigurationData{'deliver-empty-results-from-regular-search'}) ) {

                # Clean the setting and convert to lower case
                $main::ConfigurationData{'deliver-empty-results-from-regular-search'} = &sCleanSetting('deliver-empty-results-from-regular-search', $main::ConfigurationData{'deliver-empty-results-from-regular-search'});
                $main::ConfigurationData{'deliver-empty-results-from-regular-search'} = lc($main::ConfigurationData{'deliver-empty-results-from-regular-search'});
                
                # Check that the setting is valid
                if ( ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} ne "yes")  && ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} ne "no")) {
                        &vLog("Warning - configuration setting: 'deliver-empty-results-from-regular-search', setting not recognized: $main::ConfigurationData{'deliver-empty-results-from-regular-search'}.\n");
                }               
        }


        # Check 'allow-relevance-feedback-searches' (optional)
        if ( defined($main::ConfigurationData{'allow-relevance-feedback-searches'}) ) {

                # Clean the setting and convert to lower case
                $main::ConfigurationData{'allow-relevance-feedback-searches'} = &sCleanSetting('allow-relevance-feedback-searches', $main::ConfigurationData{'allow-relevance-feedback-searches'});
                $main::ConfigurationData{'allow-relevance-feedback-searches'} = lc($main::ConfigurationData{'allow-relevance-feedback-searches'});
                
                # Check that the setting is valid
                if ( ($main::ConfigurationData{'allow-relevance-feedback-searches'} ne "yes")  && ($main::ConfigurationData{'allow-relevance-feedback-searches'} ne "no")) {
                        &vLog("Warning - configuration setting: 'allow-relevance-feedback-searches', setting not recognized: $main::ConfigurationData{'allow-relevance-feedback-searches'}.\n");
                }               
        }


        # Check 'html-directory' (required)
        $main::ConfigurationData{'html-directory'} = &sCleanSetting('html-directory', $main::ConfigurationData{'html-directory'}, $main::RootDirectoryPath);
        $Value = $main::ConfigurationData{'html-directory'};
        
        # Check that the directory exists
        if ( ! (-d $Value) ) {
                &vLog("Error - configuration setting: 'html-directory', directory: '$Value' does not exist.\n");
                $Status = 0;
        }
        else {
        
                # The directory exists, now check that it can be accessed
                if ( ! ((-r $Value) && (-x $Value)) ) {
                        &vLog("Error - configuration setting: 'html-directory', directory: '$Value' cannot be accessed.\n");
                        $Status = 0;
                }
        }


        # Check 'image-base-path' (required)
        $main::ConfigurationData{'image-base-path'} = &sCleanSetting('image-base-path', $main::ConfigurationData{'image-base-path'});
        $Value = $main::ConfigurationData{'html-directory'} . $main::ConfigurationData{'image-base-path'};
        
        # Check that the directory exists
        if ( ! (-d $Value) ) {
                &vLog("Error - configuration setting: 'image-base-path', directory: '$Value' does not exist.\n");
                $Status = 0;
        }
        else {
        
                my ($ImageName);
                
                # The directory exists, now check that it can be accessed
                if ( ! ((-r $Value) && (-x $Value)) ) {
                        &vLog("Error - configuration setting: 'image-base-path', directory: '$Value' cannot be accessed.\n");
                        $Status = 0;
                }
                
                
                # Check the general icons
                foreach $ImageName ( values(%main::ImageNames) ) {

                        $Value = $main::ConfigurationData{'html-directory'} . $main::ConfigurationData{'image-base-path'} . "/" . $ImageName;
                
                        # Check that the file exists
                        if ( ! ((-f $Value) && (-r $Value)) ) {
                                &vLog("Error - configuration setting: 'image-base-path', file: '$Value' does not exist.\n");
                                $Status = 0;
                        }
                }
        }


        # Check 'html-header-snippet-file' (optional)
        if ( defined($main::ConfigurationData{'html-header-snippet-file'}) ) {

                $main::ConfigurationData{'html-header-snippet-file'} = &sCleanSetting('html-header-snippet-file', $main::ConfigurationData{'html-header-snippet-file'}, $main::RootDirectoryPath);
                $Value = $main::ConfigurationData{'html-header-snippet-file'};
                
                # Check that the file exists
                if ( ! ((-f $Value) && (-r $Value)) ) {
                        &vLog("Error - configuration setting: 'html-header-snippet-file', file: '$Value' does not exist.\n");
                        $Status = 0;
                }
        }


        # Check 'html-footer-snippet-file' (optional)
        if ( defined($main::ConfigurationData{'html-footer-snippet-file'}) ) {

                $main::ConfigurationData{'html-footer-snippet-file'} = &sCleanSetting('html-footer-snippet-file', $main::ConfigurationData{'html-footer-snippet-file'}, $main::RootDirectoryPath);
                $Value = $main::ConfigurationData{'html-footer-snippet-file'};
                
                # Check that the file exists
                if ( ! ((-f $Value) && (-r $Value)) ) {
                        &vLog("Error - configuration setting: 'html-footer-snippet-file', file: '$Value' does not exist.\n");
                        $Status = 0;
                }
        }


        # Check 'logs-directory' (required)
        $main::ConfigurationData{'logs-directory'} = &sCleanSetting('logs-directory', $main::ConfigurationData{'logs-directory'}, $main::RootDirectoryPath);
        $Value = $main::ConfigurationData{'logs-directory'};
        
        # Check that the directory exists
        if ( ! (-d $Value) ) {
                &vLog("Error - configuration setting: 'logs-directory', directory: '$Value' does not exist.\n");
                $Status = 0;
        }
        else {
        
                # The directory exists, now check that it can be accessed
                if ( ! ((-r $Value) && (-w $Value) && (-x $Value)) ) {
                        &vLog("Error - configuration setting: 'logs-directory', directory: '$Value' cannot be accessed.\n");
                        $Status = 0;
                }
        }


        # Check 'database-directory' (required)
        $main::ConfigurationData{'database-directory'} = &sCleanSetting('database-directory', $main::ConfigurationData{'database-directory'}, $main::RootDirectoryPath);
        $Value = $main::ConfigurationData{'database-directory'};
        
        # Check that the directory exists
        if ( ! (-d $Value) ) {
                &vLog("Error - configuration setting: 'database-directory', directory: '$Value' does not exist.\n");
                $Status = 0;
        }
        else {
        
                # The directory exists, now check that it can be accessed
                if ( ! ((-r $Value) && (-x $Value)) ) {
                        &vLog("Error - configuration setting: 'database-directory, directory: '$Value' cannot be accessed.\n");
                        $Status = 0;
                }
        }


        # Check 'configuration-directory' (required)
        $main::ConfigurationData{'configuration-directory'} = &sCleanSetting('configuration-directory', $main::ConfigurationData{'configuration-directory'}, $main::RootDirectoryPath);
        $Value = $main::ConfigurationData{'configuration-directory'};
        
        # Check that the directory exists
        if ( ! (-d $Value) ) {
                &vLog("Error - configuration setting: 'configuration-directory', directory: '$Value' does not exist.\n");
                $Status = 0;
        }
        else {
        
                # The directory exists, now check that it can be accessed
                if ( ! ((-r $Value) && (-x $Value)) ) {
                        &vLog("Error - configuration setting: 'configuration-directory, directory: '$Value' cannot be accessed.\n");
                        $Status = 0;
                }
        }


        # Check 'server-log' (optional with default)
        $main::ConfigurationData{'server-log'} = &sCleanSetting('server-log', $main::ConfigurationData{'server-log'});
        $Value = $main::ConfigurationData{'logs-directory'} . "/" . $main::ConfigurationData{'server-log'};
        
        # Check that we can write to the log file if it exists
        if ( -f $Value ) {

                # The file exists, now check that it can be accessed
                if ( ! -w $Value ) {
                        &vLog("Error - configuration setting: 'server-log', directory: '$Value' cannot be accessed.\n");
                        $Status = 0;
                }
        }


        # Check 'mailer-application' (optional with default)
        if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {

                $main::ConfigurationData{'mailer-application'} = &sCleanSetting('mailer-application', $main::ConfigurationData{'mailer-application'}, $main::RootDirectoryPath);
                $Value = $main::ConfigurationData{'mailer-application'};
        
                # Check that the application can be executed
                if ( ! (-x $Value) ) {
                        &vLog("Error - configuration setting: 'mailer-application', application: '$Value' cannot be executed.\n");
                        $Status = 0;
                }
        }


        return ($Status);

}


#--------------------------------------------------------------------------
#
#       Function:       bGetDatabaseDescriptions()
#
#       Purpose:        This function reads the database description file and places it in the
#                               hash table global, note that the hash table is not cleared before
#                               we start to add kay/value pairs to it.
#
#                               Any line which starts with a '#' or is empty will be skipped.
#
#                               An error will be generated if we try to redefine a value for a 
#                               key that has already been defined.
#
#                               An error here should be considered fatal.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::DatabaseDescriptions
#
#       Returns:        Boolean status
#
sub bGetDatabaseDescriptions {
        
        my ($Status, $Key, $KeyValue, $KeyBase, $KeyLeaf, $Database);
        
                
        # Init the status
        $Status = 1;


        # Only check the database description file if it is available
        if ( defined($main::ConfigurationData{'database-description-file'}) ) {

                # Open the database description file
                if ( ! open(FILE, "$main::ConfigurationData{'database-description-file'}") ) {
                        &vLog("Error - could not open database description file: '$main::ConfigurationData{'database-description-file'}'.\n");
                        return (0);
                }
                
                # Read in each line in the file, ignore empty
                # lines and lines which start with a '#'
                while (<FILE>) {
                        
                        chop $_;
        
                        # Check to see if this line is empty or is a comment, and skip them
                        if ( (length($_) == 0) || ($_ =~ /^#/) ) {
                                next;
                        }
        
                        # Split the configuration string into a set of key/value pairs
                        ($Key, $KeyValue) = split(/=/, $_);
                        
                        # Only add values which are defined
                        if ( defined($KeyValue) && ($KeyValue ne "") ) { 

                                # Split the key into a key and a subkey
                                ($KeyBase, $KeyLeaf) = split(/:/, $Key, 2);

                                if ( $KeyBase eq $main::DatabaseName ) {

                                        # Add the key/value pairs to the hash table
                                        if ( defined($main::DatabaseDescriptions{$KeyLeaf}) ) {
                                                # Fail if the value for this key is already defined
                                                &vLog("Error - value for: '$KeyLeaf', is already defined as: '$main::DatabaseDescriptions{$KeyLeaf}', tried to redefine it to: '$KeyValue'.\n");
                                                $Status = 0;
                                        }
                                        else {
                                                # Add the value for this key
                                                if ($KeyValue =~ s/(##sort[^#]+##)//) {
                                                        $main::DatabaseSort{$1} = $KeyLeaf;
                                                } else {
                                                        $main::DatabaseSort{$KeyValue} = $KeyLeaf;
                                                }
                                                $main::DatabaseDescriptions{$KeyLeaf} = $KeyValue;
                                        }
                                }
                                elsif ( $KeyBase eq $main::DatabaseFiltersPackage ) {
                                        
                                        # Add the key/value pairs to the hash table
                                        if ( defined($main::DatabaseFilters{$Key}) ) {
                                                # Fail if the value for this key is already defined
                                                &vLog("Error - value for: '$Key', is already defined as: '$main::DatabaseFilters{$Key}', tried to redefine it to: '$KeyValue'.\n");
                                                $Status = 0;
                                        }
                                        else {
                                        
                                                # Check that this filters package exists
                                                if ( ! -x $KeyValue ) {
                                                        # Fail we cant find it
                                                        &vLog("Error - filter: '$KeyValue' for: '$Key' could not be found.\n");
                                                        $Status = 0;
                                                }
                                                
                                                # Add the value for this key
                                                $main::DatabaseFilters{$Key} = $KeyValue;
                                        }
                                }
                                else {
                                
                                        ($Database) = split(/:/, $KeyLeaf);
                                        
                                        # Add the key/value pairs to the hash table
                                        if ( ! defined($main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Database"}) ) {
                                                # Fail if we dont have the package for this function
                                                &vLog("Error - package file for function: '$KeyValue', defined for: '$Key', cound not be found.\n");
                                                $Status = 0;
                                        }
                                        elsif ( defined($main::DatabaseFilters{$Key}) ) {
                                                # Fail if the value for this key is already defined
                                                &vLog("Error - value for: '$Key', is already defined as: '$main::DatabaseFilters{$Key}', tried to redefine it to: '$KeyValue'.\n");
                                                $Status = 0;
                                        }
                                        else {
                                        
                                                # Add the value for this key
                                                $main::DatabaseFilters{$Key} = $KeyValue;
                                        }
                                }
                        }
                }
                close(FILE);
        }

        # fill defaults for rest
        $main::DatabaseFilters{$Key} = $main::DatabaseFilters{default} if (! defined($main::DatabaseFilters{$Key}));

        return ($Status);

}


#--------------------------------------------------------------------------
#
#       Function:       bInitializeServer()
#
#       Purpose:        This function sets up the server
#
#                               An error here should be considered fatal.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData
#
#       Returns:        Boolean status
#
sub bInitializeServer {

        my ($Status, $Text);
        my ($ErrorNumber, $ErrorMessage);

        
        # Initialize the server
        ($Status, $Text) = MPS::InitializeServer($main::ConfigurationData{'database-directory'}, $main::ConfigurationData{'configuration-directory'}, $main::ConfigurationData{'logs-directory'} . "/". $main::ConfigurationData{'server-log'}, MPS_LOG_MEDIUM);

        # Check the return code
        if ( ! $Status ) {
                ($ErrorNumber, $ErrorMessage) = split(/\t/, $Text, 2);
                &vHandleError("Database Search", "Sorry, failed to initialize the server");
                print("The following error message was reported: <BR>\n");
                print("Error Message: $ErrorMessage <BR>\n");
                print("Error Number: $ErrorNumber <BR>\n");
        }
        
        $main::MPSSession = $Text;

        return ($Status);
}


#--------------------------------------------------------------------------
#
#       Function:       bShutdownServer()
#
#       Purpose:        This function shuts down the server
#
#                               An error here should be considered fatal.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData
#
#       Returns:        Boolean status
#
sub bShutdownServer {


        # Shutdown the server
        MPS::ShutdownServer($main::MPSSession);

        return (1);

}


#--------------------------------------------------------------------------
#
#       Function:       bCheckCGIEnvironment()
#
#       Purpose:        This function checks that all the CGI environment variables we
#                               need are available. It will exit if any of the variables are
#                               not found, but it will first list all the variables that are
#                               not available.
#
#                               An error here should be considered fatal.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       $ENV{}
#
#       Returns:        Boolean status
#
sub bCheckCGIEnvironment {

        my ($Status);


        # Init the status
        $Status = 1;


        # Check that REQUEST_METHOD is specified
        if ( ! (defined($ENV{'REQUEST_METHOD'}) && ($ENV{'REQUEST_METHOD'} ne "")) ) {
                &vLog("Error - missing 'REQUEST_METHOD' environment variable.\n");
                $Status = 0;
        }
        

        # Check that SCRIPT_NAME is specified
        if ( ! (defined($ENV{'SCRIPT_NAME'}) && ($ENV{'SCRIPT_NAME'} ne "")) ) {
                &vLog("Error - missing 'SCRIPT_NAME' environment variable.\n");
                $Status = 0;
        }


# Force guest
#$ENV{'REMOTE_USER'} = "guest";

        # Make sure that REMOTE_USER is defined, we set it to an empty string if it is not
        if ( ! (defined($ENV{'REMOTE_USER'}) && ($ENV{'REMOTE_USER'} ne "")) ) {
                $ENV{'REMOTE_USER'} = "";
        }
        else {
                # REMOTE_USER is defined, we check to see if the guest account name is defined
                if ( defined($main::ConfigurationData{'guest-account-name'}) ) {
                        # Set the REMOTE_USER to an empty string if it is the same as the guest account
                        if ( $ENV{'REMOTE_USER'} eq $main::ConfigurationData{'guest-account-name'} ) {
                                $ENV{'REMOTE_USER'} = "";
                        }
                }
        }


        # Adjust the path info if needed
        if ( defined($ENV{'PATH_INFO'}) && defined($ENV{'SCRIPT_NAME'}) && (length($ENV{'PATH_INFO'}) > length($ENV{'SCRIPT_NAME'})) ) {
                if ( substr($ENV{'PATH_INFO'}, 0, length($ENV{'SCRIPT_NAME'})) eq $ENV{'SCRIPT_NAME'} ) {
                        $ENV{'PATH_INFO'} = substr($ENV{'PATH_INFO'}, length($ENV{'SCRIPT_NAME'}));
                        $ENV{'PATH_INFO'} = undef if ($ENV{'PATH_INFO'} eq "");
                }
        }


        return ($Status);

}


#--------------------------------------------------------------------------
#
#       Function:       bSetupCGIEnvironment()
#
#       Purpose:        This function sets up the environment for the CGI mode, it will
#                               also check that all the globals are correct and that any
#                               required directories can be accessed and written to
#
#                               An error here should be considered fatal.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       $main::UserAccountDirectoryPath, $main::UserSettingsFilePath, $main::RemoteUser,
#                                               %main::FormData, %main::ConfigurationData
#
#       Returns:        Boolean status
#
sub bSetupCGIEnvironment {

        my ($Status, $URLString);


        # Init the status
        $Status = 1;


        # Get the query string from the environment
        if ( $ENV{'REQUEST_METHOD'} eq "GET" ) {
                $URLString = $ENV{'QUERY_STRING'};
        }
        # Get the query string from stdin
        elsif ( $ENV{'REQUEST_METHOD'} eq "POST" ) {
                read("STDIN", $URLString, $ENV{'CONTENT_LENGTH'});

                # Append the query string if it is defined
                if ( defined($ENV{'QUERY_STRING'}) && ($ENV{'QUERY_STRING'} ne "") ) {
                        $URLString = $ENV{'QUERY_STRING'} . "&". $URLString;
                }
        }


        # Parse the form data that was passed
        if ( defined($URLString) && ($URLString ne "") ) {
                %main::FormData = &hParseURLIntoHashTable($URLString);
        }

        
        # Get the REMOTE_USER from the CGI environment and set the user account directory path
        if ( (defined($ENV{'REMOTE_USER'})) && ($ENV{'REMOTE_USER'} ne "") && defined($main::ConfigurationData{'user-accounts-directory'}) ) {
                $main::RemoteUser = $ENV{'REMOTE_USER'};
                $main::UserAccountDirectoryPath = $main::ConfigurationData{'user-accounts-directory'} . "/". $main::RemoteUser;
                $main::UserAccountDirectoryPath =~ tr/\+/ /;
                $main::UserSettingsFilePath = $main::UserAccountDirectoryPath . "/". $main::UserSettingsFileName . $main::XMLFileNameExtension;
        }
        else {
                undef($main::RemoteUser);
                undef($main::UserAccountDirectoryPath);
                undef($main::UserSettingsFilePath);
        }


        # Check that the user account directory exists if it is specified
        if ( defined($main::UserAccountDirectoryPath) ) {
                
                # Try to create the user account directory if it does not exist
                if ( ! -d $main::UserAccountDirectoryPath ) {
                        
                        if ( mkdir($main::UserAccountDirectoryPath, 0700) ) {
                                
                                # Set the user account directory so that it can be accessed by ourselves only
                                chmod(0700, $main::UserAccountDirectoryPath);

                        }
                        else {
                                
                                # The directory could not be created, so we inform the user of the fact
                                &vHandleError("User Account Error", "Sorry, the account directory could not be created");
                                $Status = 0;
                        }
                }


                # Check that we can access user account directory
                if ( ! ((-r $main::UserAccountDirectoryPath) && (-w $main::UserAccountDirectoryPath) && (-x $main::UserAccountDirectoryPath)) ) {
                        
                        # The directory cannot be accessed, so we inform the user of the fact
                        &vHandleError("User Account Error", "Sorry, the account directory could not be accessed");
                        $Status = 0;
                }
        }


        return ($Status);

}


#--------------------------------------------------------------------------
#
#       Function:       sMakeSearchURL()
#
#       Purpose:        This function makes a search URL from the passed content hash.
#
#       Called by:      
#
#       Parameters:     %Content                content hash
#
#       Global Variables:       none
#
#       Returns:        the URL search string, and an empty string if
#                               nothing relevant is defined in the content
#
sub sMakeSearchURL {

        my (%Content) = @_;

        my ($SearchURL, $Value);
        my (@InternalFieldNames) = ('Any', 'Operator', 'Past', 'Since', 'Before', 'LastRunTime', 'Order', 'Max', 'Database');

        
        # Initialize the search URL
        $SearchURL = "";


        # Add the generic field names
        foreach $Value ( 1..100 ) {
        
                my ($FieldName) = "FieldName" . $Value;
                my ($FieldContent) = "FieldContent" . $Value;
                
                if ( defined($Content{$FieldName}) ) {
                        $SearchURL .= "&$FieldName=" . &lEncodeURLData($Content{$FieldName});
                        $SearchURL .= defined($Content{$FieldContent}) ? "&$FieldContent=" . &lEncodeURLData($Content{$FieldContent}) : "";
                }
        }


        # Add the internal search terms
        foreach $Value ( @InternalFieldNames ) {
                $SearchURL .= defined($Content{$Value}) ? "&$Value=" . join("&$Value=", &lEncodeURLData(split(/\0/, $Content{$Value}))) : "";
        }


        # Return the URL, choping out the initial '&'
        return (($SearchURL ne "") ? substr($SearchURL, 1) : "");

}


#--------------------------------------------------------------------------
#
#       Function:       sMakeDocumentURL()
#
#       Purpose:        This function makes a document URL from the passed content hash.
#
#       Called by:      
#
#       Parameters:     %Content                content hash
#
#       Global Variables:       none
#
#       Returns:        the URL document string, and an empty string if
#                               nothing relevant is defined in the content
#
sub sMakeDocumentURL {

        my (%Content) = @_;

        my ($DocumentURL);


        # Initialize the document URL
        $DocumentURL = "";


        # Add the document URLs
        if ( defined($Content{'Document'}) ) {
                $DocumentURL .= "&Document=" . join("&Document=", &lEncodeURLData(split(/\0/, $Content{'Document'})));
        }


        # Return the URL, choping out the initial '&'
        return (($DocumentURL ne "") ? substr($DocumentURL, 1) : "");

}


#--------------------------------------------------------------------------
#
#       Function:       sMakeRfDocumentURL()
#
#       Purpose:        This function makes an RF document URL from the passed content hash.
#
#       Called by:      
#
#       Parameters:     %Content                content hash
#
#       Global Variables:       none
#
#       Returns:        the URL RF document string, and an empty string if
#                               nothing relevant is defined in the content
#
sub sMakeRfDocumentURL {

        my (%Content) = @_;

        my ($RfDocumentURL);


        # Initialize the RF document URL
        $RfDocumentURL = "";
        

        # Add the RF document URLs
        if ( defined($Content{'RfDocument'}) ) {
                $RfDocumentURL .= "&RfDocument=" . join("&RfDocument=", &lEncodeURLData(split(/\0/, $Content{'RfDocument'})));
        }


        # Return the URL, choping out the initial '&'
        return (($RfDocumentURL ne "") ? substr($RfDocumentURL, 1) : "");

}


#--------------------------------------------------------------------------
#
#       Function:       sMakeSearchAndRfDocumentURL()
#
#       Purpose:        This function makes a URL string from the search
#                               and RF document URLs
#
#       Called by:      
#
#       Parameters:     %Content                content hash
#
#       Global Variables:       none
#
#       Returns:        the URL query string, and an empty string if
#                               nothing relevant is defined in %Content
#
sub sMakeSearchAndRfDocumentURL {

        my (%Content) = @_;

        my ($SearchURL, $RfDocumentURL, $SearchRfDocumentURL);


        # Get the search URL and the RF document URL
        $SearchURL = &sMakeSearchURL(%Content);
        $RfDocumentURL = &sMakeRfDocumentURL(%Content);
        

        # Concatenate them intelligently
        $SearchRfDocumentURL = $SearchURL . ((($SearchURL ne "") && ($RfDocumentURL ne "")) ? "&" : "") . $RfDocumentURL;


        # Return the URL
        return ($SearchRfDocumentURL);

}


#--------------------------------------------------------------------------
#
#       Function:       sMakeSearchString()
#
#       Purpose:        This function makes a search string from the search 
#                               variables in the content hash
#
#       Called by:      
#
#       Parameters:     %Content                content hash
#
#       Global Variables:       void
#
#       Returns:        the search string, and an empty string if
#                               nothing relevant is defined in the content hash
#
sub sMakeSearchString {

        my (%Content) = @_;

        my ($SearchString);
        my ($FieldName, $Time, $Date);
        my ($Value);


        # Initialize the search string
        $SearchString = "";

sub nuke_accents {
        my $tmp = $_[0];
        $tmp =~ tr/Çüéâäùæç³ëÕõî¬ÄÆÉÅåôö¥µ¦¶ÖÜ«»£èáíóú¡±®¾Êê¼ÈºÁÂÌª¯¿ÃãðÐÏËïÒÍÎìÞÙÓÔÑñò©¹ÀÚàÛýÝþ´½²·¢¸¨ÿØø/CueaauccleOoiZACELlooLlSsOUTtLcaiouAaZzEezCsAAESZzAadDDEdNIIeTUOoNnnSsRUrUyYt'-".'',"'Rr/;
        # convert search string to lower case -> make search case insensitive
        $tmp =~ tr/A-Z/a-z/;
        return $tmp;
}


        # Add the search terms
        $SearchString .= defined($Content{'Any'}) ? ((($SearchString ne "") ? " AND " : "") . nuke_accents($Content{'Any'}) ) : "";


        # Add the generic field names
        foreach $Value ( 1..100 ) {
        
                my ($FieldName) = "FieldName" . $Value;
                my ($FieldContent) = "FieldContent" . $Value;

        
                if ( defined($Content{$FieldName}) && defined($Content{$FieldContent}) ) {
        
                        if ($Content{$FieldName} eq "ISBN") {
                                # fix stupid problem with dashes in data
                                $Content{$FieldContent} .= "*";
                        }

                        $SearchString .=  ($SearchString ne "") ? " AND " : "";
                        $SearchString .= "$Content{$FieldName}=(" . nuke_accents($Content{$FieldContent}) . ")";
                }
        }

        # Add the internal search terms

        # Add the date restriction on the load time
        if ( defined($Content{'LastRunTime'}) && ($Content{'LastRunTime'} > 0) ) {
                $SearchString .= (($SearchString ne "") ? " AND " : "") . "time_t>=$Content{'LastRunTime'}";
        }


        # Add the Past date restriction
        if ( defined($Content{'Past'}) && ($Content{'Past'} ne "0") ) {
                
                $Time = time();
                if ( $Content{'Past'} eq "Day" ) {
                        $Time = &tSubstractFromTime($Time, undef, undef, 1);
                }
                elsif ( $Content{'Past'} eq "Week" ) {
                        $Time = &tSubstractFromTime($Time, undef, undef, 7);
                }
                elsif ( $Content{'Past'} eq "Month" ) {
                        $Time = &tSubstractFromTime($Time, undef, 1, undef);
                }
                elsif ( $Content{'Past'} eq "3 Months" ) {
                        $Time = &tSubstractFromTime($Time, undef, 3, undef);
                }
                elsif ( $Content{'Past'} eq "6 Months" ) {
                        $Time = &tSubstractFromTime($Time, undef, 6, undef);
                }
                elsif ( $Content{'Past'} eq "9 Months" ) {
                        $Time = &tSubstractFromTime($Time, undef, 9, undef);
                }
                elsif ( $Content{'Past'} eq "Year" ) {
                        $Time = &tSubstractFromTime($Time, 1, undef undef);
                }
                
                # Create an ANSI format date/time field 
                $Date = &sGetAnsiDateFromTime($Time);
                $SearchString .= " {DATE>=$Date}";
        }


        # Add the Since date restriction
        if ( defined($Content{'Since'}) && ($Content{'Since'} ne "0") ) {
                $SearchString .= " {DATE>=$Content{'Since'}0000}";
        }


        # Add the Before date restriction
        if ( defined($Content{'Before'}) && ($Content{'Before'} ne "0") ) {
                $SearchString .= " {DATE<$Content{'Before'}0000}";
        }


        # Add the document sort order
        $SearchString .= defined($Content{'Order'}) ? " {" . $Content{'Order'} . "}" : "";

        # Add the operator
        $SearchString .= defined($Content{'Operator'}) ? " {" . $Content{'Operator'} . "}" : "";


        return (($SearchString ne "") ? $SearchString : undef);

}


#--------------------------------------------------------------------------
#
#       Function:       hGetSearchStringHash()
#
#       Purpose:        This function makes a search string hash table from the search 
#                               variables in the content hash
#
#       Called by:      
#
#       Parameters:     %Content                content hash
#
#       Global Variables:       void
#
#       Returns:        the search string hash table, and an empty string if
#                               nothing relevant is defined in the content hash
#
sub hGetSearchStringHash {

        my (%Content) = @_;

        my ($Content);
        my (%Value, @Values, $Value);


        @Values = split(/ /, defined($Content{'Any'}) ? $Content{'Any'} : "");
        foreach $Value ( @Values ) { $Value = lc($Value); $Value{$Value} = $Value };                    
        

        # Add the generic field names
        foreach $Value ( 1..100 ) {
        
                my ($FieldName) = "FieldName" . $Value;
                my ($FieldContent) = "FieldContent" . $Value;
                
                if ( defined($Content{$FieldName}) ) {
                        @Values = split(/ /, defined($Content{$FieldContent}) ? $Content{$FieldContent} : "");
                        foreach $Value ( @Values ) { $Value = lc($Value); $Value{$Value} = $Value };                    
                }
        }


        return (%Value);

}


#--------------------------------------------------------------------------
#
#       Function:       hGetDocumentFolders()
#
#       Purpose:        This function returns a hash table of all the document folders
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       void
#
#       Returns:        a hash table of document folders, the key being the folder name
#                               and the content being the folder file name
#
sub hGetDocumentFolders {

        my (@DocumentFolderList, $DocumentFolderEntry, $HeaderName, $FolderName, %QualifiedDocumentFolders);

        # Read all the document folder files
        opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
        @DocumentFolderList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::DocumentFolderFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
        closedir(USER_ACCOUNT_DIRECTORY);


        # Loop over each document folder file checking that it is valid
        for $DocumentFolderEntry ( @DocumentFolderList ) {
                
                # Get the header name from the XML document folder file
                $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderEntry);

                # Check that the entry is valid and add it to the qualified list
                if ( defined($HeaderName) && ($HeaderName eq "DocumentFolder") ) {
                        $FolderName = &sGetTagValueFromXMLFile($DocumentFolderEntry, "FolderName");
                        $QualifiedDocumentFolders{$FolderName} = $DocumentFolderEntry;
                }
                else {
                        # Else we delete this invalid document folder file
                        unlink($DocumentFolderEntry);
                }
        }


        return (%QualifiedDocumentFolders);

}


#--------------------------------------------------------------------------
#
#       Function:       iSaveSearchHistory()
#
#       Purpose:        This function saves the passed search to a new
#                               search history XML file.
#
#       Called by:      
#
#       Parameters:     $FileName                                       search history file name ('undef' means create a new file name)
#                               $SearchAndRfDocumentURL         search and RF document URL
#                               $SearchResults                          search results
#                               $QueryReport                            query report
#
#       Global Variables:       $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::SearchHistoryFileNamePrefix
#
#       Returns:        0 on error, 1 on success
#
sub iSaveSearchHistory {

        my ($FileName, $SearchAndRfDocumentURL, $SearchResults, $QueryReport) = @_;
        my ($SearchHistoryFilePath, %Value);
        my ($AnsiDateTime);


        # Return an error if the user account directory is not defined
        if ( !(defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                return (0);
        }
        
        # Create a file name if one was not passed 
        if ( !defined($FileName) ) {
                $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
                $SearchHistoryFilePath = $main::UserAccountDirectoryPath . "/". $main::SearchHistoryFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
        }
        else {
                $SearchHistoryFilePath = $FileName;
        }       


        # Set the hash from the history information
        undef(%Value);
        $Value{'CreationTime'} = time();
        $Value{'SearchAndRfDocumentURL'} = $SearchAndRfDocumentURL;
        $Value{'QueryReport'} = $QueryReport;
        $Value{'SearchResults'} = $SearchResults;


        # Save the search information
        if ( ! &iSaveXMLFileFromHash($SearchHistoryFilePath, "SearchHistory", %Value) ) {
                # Failed to save the information, so we return an error
                return (0);
        }

        return (1);

}


#--------------------------------------------------------------------------
#
#       Function:       iSaveSearch()
#
#       Purpose:        This function saves the passed search to a new
#                               search XML file.
#
#       Called by:      
#
#       Parameters:     $FileName                                       saved search file name ('undef' means create a new file name)
#                               $SearchName                                     search name
#                               $SearchDescription                      search description
#                               $SearchAndRfDocumentURL         search and RF document URL
#                               $SearchFrequency                        search frequency
#                               $DeliveryFormat                         delivery format
#                               $DeliveryMethod                         delivery method
#                               $SearchStatus                           search status
#                               $CreationTime                           creation time
#                               $LastRunTime                            last run time
#                               
#       Global Variables:       $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::SavedSearchFileNamePrefix
#
#       Returns:        0 on error, 1 on success
#
sub iSaveSearch {

        my ($FileName, $SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $LastRunTime) = @_;
        my ($SavedSearchFilePath, %Value);
        my ($AnsiDateTime);

        
        # Return an error if the user account directory is not defined
        if ( !(defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                return (0);
        }
        
        # Create a file name if one was not passed 
        if ( !defined($FileName) ) {
                $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
                $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/". $main::SavedSearchFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
        }
        else {
                $SavedSearchFilePath = $FileName;
        }       


        # Set the hash from the search information
        undef(%Value);
        $Value{'SearchName'} = $SearchName;
        $Value{'SearchDescription'} = $SearchDescription;
        $Value{'SearchAndRfDocumentURL'} = $SearchAndRfDocumentURL;
        $Value{'SearchFrequency'} = $SearchFrequency;
        $Value{'DeliveryFormat'} = $DeliveryFormat;
        $Value{'DeliveryMethod'} = $DeliveryMethod;
        $Value{'SearchStatus'} = $SearchStatus;
        $Value{'CreationTime'} = $CreationTime;
        $Value{'LastRunTime'} = $LastRunTime;

        
        # Save the search information
        if ( ! &iSaveXMLFileFromHash($SavedSearchFilePath, "SavedSearch", %Value) ) {
                # Failed to save the information, so we return an error
                return (0);
        }

        return (1);

}


#--------------------------------------------------------------------------
#
#       Function:       iSaveFolder()
#
#       Purpose:        This function saves the passed folder to a new
#                               document folder XML file.
#
#       Called by:      
#
#       Parameters:     $FileName                                       document folder file name ('undef' means create a new file name)
#                               $FolderName                                     folder name
#                               $FolderDescription                      folder description
#                               $FolderDocuments                        folder document
#                               $CreationTime                           creation time
#                               $UpdateTime                                     update time
#                               
#       Global Variables:       $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::DocumentFolderFileNamePrefix
#
#       Returns:        0 on error, 1 on success
#
sub iSaveFolder {
        
        my ($FileName, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) = @_;
        my ($DocumentFolderFilePath, %Value);
        my ($AnsiDateTime);

        
        # Return an error if the user account directory is not defined
        if ( !defined($main::RemoteUser) || !defined($main::UserAccountDirectoryPath) ) {
                return (0);
        }
        
        # Create a file name if one was not passed 
        if ( !defined($FileName) ) {
                $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
                $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/". $main::DocumentFolderFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
        }
        else {
                $DocumentFolderFilePath = $FileName;
        }       


        # Set the hash from the folder information
        undef(%Value);
        $Value{'FolderName'} = $FolderName;
        $Value{'FolderDescription'} = $FolderDescription;
        $Value{'FolderDocuments'} = $FolderDocuments;
        $Value{'CreationTime'} = $CreationTime;
        $Value{'UpdateTime'} = $UpdateTime;

        
        # Save the document folder information
        if ( ! &iSaveXMLFileFromHash($DocumentFolderFilePath, "DocumentFolder", %Value) ) {
                # Failed to save the information, so we return an error
                return (0);
        }

        return (1);

}


#--------------------------------------------------------------------------
#
#       Function:       bDisplayDocuments()
#
#       Purpose:        This function displays the document
#
#       Called by:      
#
#       Parameters:     $Title                          title
#                               $Documents                      \0 separated document URL
#                               $FieldName                      field name
#                               $Selector                       true to display selector
#                               $Selected                       selector is selected
#                               $HTML                           true to display HTML
#                               
#
#       Global Variables:       void
#
#       Returns:        the status
#
sub bDisplayDocuments {

        my ($Title, $Documents, $FieldName, $Selector, $Selected, $HTML) = @_;

        my (@Documents, $Document, $Status, $DocumentInfo, $SelectorText, $SelectedText, $LinkText);
        my ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder);
        my (%Value, $Value, @Values);
        

        # Check input parameters
        if ( !defined($Documents) ) {
                return (0);
        }
        
        
        # Split the documents text into a documents list
        @Documents = split(/\0/, $Documents);                   

        
        # Set the field name
        $FieldName = (defined($FieldName ) && ($FieldName  ne "")) ? $FieldName : "Document";

        # Set the selected text
        $SelectedText = ((defined($Selector) && $Selector) && (defined($Selected) && $Selected)) ? "CHECKED" : "";


        # Print the title
        if ( $HTML ) {
                printf("<TD ALIGN=LEFT VALIGN=TOP>%s%s:</TD><TD ALIGN=LEFT VALIGN=TOP>\n", 
#                               defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
                                $Title);
        }
        else {
#               printf("%s%s:\n", defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
                print $Title;
        }


        # Loop over each entry in the documents list
        foreach $Document ( @Documents ) {
        
                # Parse out the document entry
                %Value = &hParseURLIntoHashTable($Document);
                
                # Get the document information
                ($Status, $DocumentInfo) = MPS::GetDocumentInfo($main::MPSSession, $Value{'Database'}, $Value{'DocumentID'});
        
                if ( $Status ) {
                        ($Headline, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $DocumentInfo, 8);
                
                        # Decode the headline and strip the HTML
                        $Headline = &lDecodeURLData($Headline);
                        $Headline =~ s/&nbsp;//gs;
                        $Headline =~ s/<.*?>//gs;
                        $Headline =~ s/\s+/ /gs;
                        # decode some basic html from headline <b> <i>
                        $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;
                        
                        # Create a generic link for this document
                        $Value = "";
                        $Value .= (defined($Value{'Database'}) && ($Value{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Value{'Database'}) : "";
                        $Value .= (defined($Value{'DocumentID'}) && ($Value{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Value{'DocumentID'}) : "";
                        $Value .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
                        $Value .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";


                        # Create the selector text
                        if ( defined($Selector) && $Selector ) {
                                $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"$FieldName\" VALUE=\"" . substr($Value, 1) . "\" $SelectedText> ";
                        }
                        else {
                                $SelectorText = " - ";
                        }

                        # Create the link text, we use the URL if it is there
                        if ( defined($URL) && ($URL ne "") ) {
                                $LinkText = $URL;
                        }
                        elsif ( defined($Value{'DocumentID'}) && ($Value{'DocumentID'} ne "") ) {
                                $LinkText = "$ENV{'SCRIPT_NAME'}/GetDocument?" . substr($Value, 1);
                        }
                        else {
                                $LinkText = "";
                        }
 
                        # Put up the headline and the score, this one links to the document
                        if ( $HTML ) {
#                               print("$SelectorText <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline <I> ( $main::DatabaseDescriptions{$Value{'Database'}} ) </I> </A> <BR>\n");
                                print("$SelectorText <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline </A> <BR>\n");

#                               if ( defined($URL) && ($URL ne "") ) {
#                                       $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
#                                       print("<FONT SIZE=-2><A HREF=\"$URL\"> $Value </A></FONT><BR>\n");
#                               }
                        }
                        else {
                                print("- $Headline ($main::DatabaseDescriptions{$Value{'Database'}})\n   URL: $LinkText\n");
                        }
                }
        }
        
        if ( $HTML ) {
                print("</TD>\n");
        }
                

        return (1);

}


#--------------------------------------------------------------------------
#
#       Function:       bsDisplaySearchResults()
#
#       Purpose:        This function displays the search results
#
#       Called by:      
#
#       Parameters:     $Title                          title
#                               $SearchResults          search results
#                               $SearchDate                     search date
#                               $SearchFrequency        search frequency
#                               $SearchDescription      search description
#                               $QueryReport            query report
#                               $ScriptName                     script name
#                               $Header                         true to display header
#                               $Selector                       true to display selector
#                               $HTML                           true to display HTML
#                               %Content                        content hash table
#                               
#
#       Global Variables:       %main::ConfigurationData, $main::RemoteUser,
#                                               $main::QueryReportItemName, $main::QueryReportMimeType
#
#       Returns:        the status and a the query report
#
sub bsDisplaySearchResults {

        my ($Title, $SearchDescription, $SearchDate, $SearchFrequency, $SearchResults, $QueryReport, $ScriptName, $Header, $Selector, $HTML, %Content) = @_;

        my ($SearchString, $SummaryType, $SummaryLength, @SearchResults, $SearchResult, $FinalQueryReport, $ResultCount, %SearchStringHash);
        my ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder);
        my ($Status, $Text, $MimeTypeName, $SummaryText, $SelectorText, $LinkText, $RuleFlag, $LastItemName);
        my (@DocumentFolderList, %QualifiedDocumentFolders, $DocumentFolderEntry, $HeaderName, $FolderName, $Index);
        my (@Words, $Word, @OffsetPairs, $OffsetPair, %Offsets, $Offset, $Start, $End, $OldStart, $OldEnd, $CurrentSummaryLength);
        my ($DatabaseSummaryFilterKey, $DatabaseSummaryFilterFunction);
        my ($Value, %Value, @Values, $ValueEntry);


        # Check input parameters
        if ( !defined($SearchResults) || !%Content ) {
                return (0);
        }
        
        # Split the search results text into a search results list
        @SearchResults = split(/\n/, $SearchResults);                   
        
        
        # First we count up the number of results and scoop up
        # any query reports if we need to

        # Initialize the final query report
        if ( !defined($QueryReport) ) {
                $FinalQueryReport = "";
        }
        else {
                $FinalQueryReport = $QueryReport;
        }

                
        # Loop over each entry in the search results list
        $ResultCount = 0;
        foreach $SearchResult ( @SearchResults ) {
                
                # Parse the headline, also get the first document item/type
                ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);

                # Is this a query report
                if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {

                        # Retrieve the query report if it was not passed to us
                        if ( !defined($QueryReport) ) {
                                ($Status, $Text) = MPS::GetDocument($main::MPSSession, $Database, $DocumentID, $ItemName, $MimeType);
        
                                if ( $Status ) {
                                        # Concatenate it to the query report text we have already got
                                        $FinalQueryReport .= $Text;
                                }
                        }
                }
                else {
                        # Increment the result count
                        $ResultCount++;
                }
        }


        # Finally, we get information we are going to need later on

        # Get the search string
        $SearchString = &sMakeSearchString(%Content);
        if ( defined($SearchString) ) {
                $SearchString =~ s/{.*?}//gs;
                $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
        }
        $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";

        # Get the search string hash
        %SearchStringHash = &hGetSearchStringHash(%Content); 

        # Do some very basic plural stemming
        foreach $Value ( keys (%SearchStringHash) ) {
                $Value =~ s/ies\Z/y/g;
                $Value =~ s/s\Z//g;
                $SearchStringHash{$Value} = $Value;
        }


        # Get the summary information
        if ( defined($main::RemoteUser) ) {
        
                $SummaryType = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SummaryType");
                $SummaryLength = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SummaryLength");
                
                if ( !(defined($SummaryLength) && ($SummaryLength ne "")) ) {
                        $SummaryLength = $main::DefaultSummaryLength;
                }
                if ( !(defined($SummaryType) && ($SummaryType ne "")) ) {
                        $SummaryType = $main::DefaultSummaryType;
                }
        }
        else {
                $SummaryType = $main::DefaultSummaryType;
                $SummaryLength = $main::DefaultSummaryLength;
        }


        # Print the header if needed
        if ( $Header ) {
                
                if ( $HTML ) {
                        # Print the title and the start of the form
                        printf("<H3>%s</H3>\n", defined($Title) ? $Title : "Rezultati pretra¾ivanja:");
        
                        # Start the form
                        print("<FORM ACTION=\"$ScriptName\" METHOD=POST>\n");
                
        
                        # List the hidden fields
                        %Value = &hParseURLIntoHashTable(&sMakeSearchURL(%Content));
                        foreach $Value ( keys(%Value) ) {
                                foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
                                        print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
                                }
                        }
                
                
                        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
        
                        # Print the selector
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP>Odabrani su svi rezultati ukoliko niste uèinili nikakav dodatan odabir.</TD><TD ALIGN=RIGHT VALIGN=TOP> \n");
                        
                        if ( $ResultCount > 0 ) {
                                
                                if ( defined($main::RemoteUser) ) {
                                        print("<SELECT NAME=\"Action\">\n");
                                        
                                        print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
                                        if
( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
                                        print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
                                        }
                                        if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
                                                print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
                                        }
                                        print("<OPTION VALUE=\"GetSaveSearch\">Saèuvaj upit\n");
                                        print("<OPTION VALUE=\"GetSaveFolder\">Saèuvaj odabrane rezultate u novi folder\n");
                        
                                        # Get the document folder hash
                                        %QualifiedDocumentFolders = &hGetDocumentFolders;
                        
                                        for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
                                                
                                                $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
                                        
                                                # Get the document folder file name and encode it
                                                $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
                                                $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
                                                
                                                print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry\">Dodaj odabrane rezultate u '$FolderName' folder\n");
                                        }
                                        print("</SELECT>\n");
                                        print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
                                }
                                else {
                                        print("<SELECT NAME=\"Action\">\n");
                                        print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
                                        if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
                                                print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
                                        }
                                        if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
                                                print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
                                        }
                                        print("</SELECT>\n");
                                        print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
                                }
                        }
                        else {
                                if ( defined($main::RemoteUser) ) {
                                        print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSaveSearch\">\n");
                                        print("<INPUT TYPE=SUBMIT VALUE=\"Save this search\">\n");
                                }
                        }
                
                        print("</TD></TR>\n");
                        print("</TABLE>\n");
                }
                else {
                        printf("%s\n", defined($Title) ? $Title : "Rezultati pretra¾ivanja:");
                }
        
        
                # Display the search string
                if ( $HTML ) {
                        print("<CENTER><HR WIDTH=50%></CENTER>\n");
                        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
                }
                else {
                        print("--------------------------------------------------------------\n");
                        print(" - Search for       : $SearchString\n");
                }
        
        
                # Display the description
                if ( defined($SearchDescription) ) {
                        if ( $HTML ) {
                                $SearchDescription =~ s/\n/<BR>/g;
                                $SearchDescription =~ s/\r/<BR>/g;
                                print("<TR><TD ALIGN=LEFT VALIGN=TOP>  Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDescription </TD></TR>\n");
                        }
                        else {
                                print(" - Description      : $SearchDescription\n");
                        }
                }
        
                # Display the date
                if ( defined($SearchDate) ) {
                        if ( $HTML ) {
                                print("<TR><TD ALIGN=LEFT VALIGN=TOP>  Run on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDate </TD></TR>\n");
                        }
                        else {
                                print(" - Run on           : $SearchDate\n");
                        }
                }
        
                # Display the frequency
                if ( defined($SearchFrequency) ) {
                        if ( $HTML ) {
                                print("<TR><TD ALIGN=LEFT VALIGN=TOP>  Frequency: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchFrequency </TD></TR>\n");
                        }
                        else {
                                print(" - Frequency        : $SearchFrequency\n");
                        }
                }
        
        
                # Get the databases from the search and list their descriptions
                if ( defined($Content{'Database'}) ) {
        
                        # Initialize the temp list
                        undef(@Values);
        
                        # Loop over each database
                        foreach $Database ( split(/\0/, $Content{'Database'}) ) {
                                $Value = &lEncodeURLData($Database);
                                if ( $HTML ) {
                                        push @Values, sprintf("<A HREF=\"$ScriptName/GetDatabaseInfo?Database=$Value\" OnMouseOver=\"self.status='Get Information about the $main::DatabaseDescriptions{$Database} database'; return true\"> $main::DatabaseDescriptions{$Database} </A> ");
                                }
                                else {
                                        push @Values, sprintf("$main::DatabaseDescriptions{$Database} ");
                                }
                        }
        
                        # Print the list if there are any entries in it
                        if ( scalar(@Values) > 0 ) {
                                if ( $HTML ) {
                                        printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s  </TD></TR>\n", 
                                                        (scalar(@Values) > 1) ? "s" : "", join(", ", @Values));
                                }
                                else {
                                        printf(" - Database%s        : %s\n", (scalar(@Values) > 1) ? "s" : " ", join(", ", @Values));
                                }
                        }
                }
        
        
                # Display any feedback documents
                if ( defined($Content{'RfDocument'}) ) {
                        if ( $HTML ) {
                                print("<TR>\n");
                        }
                        &bDisplayDocuments("Feedback Document", $Content{'RfDocument'}, "RfDocument", 1, 1, $HTML);
                        if ( $HTML ) {
                                print("</TR>\n");       
                        }
                }


                if ( $HTML ) {
                        printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Pronaðeno: </TD> <TD ALIGN=LEFT VALIGN=TOP> <font color=\"#990000\"> %s rezultata </font>(Maksimalni broj pode¹en na: $Content{'Max'} )  </TD></TR>\n",
                                        ($ResultCount > 0) ? $ResultCount : "no");
                
                        print("</TABLE>\n");
                        print("<CENTER><HR WIDTH=50%></CENTER>\n");
                }
                else {
                        printf(" - Results          : %s\n", ($ResultCount > 0) ? $ResultCount : "no");
                        print("--------------------------------------------------------------\n\n");
                }
        }


        # Start the table
        if ( $HTML ) {
                print("<!-- searchResults -->\n");
                print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

                # Display a button to select all the documents
                if ( $ResultCount > 0 ) {
                
                        if ( defined($Selector) && $Selector ) {
                                
                                $SelectorText = "";
                                
                                # Loop over each entry in the hits list
                                foreach $SearchResult ( @SearchResults ) {
                        
                                        # Parse the headline, also get the first document item/type
                                        ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
                        
                                        # Skip query reports
                                        if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
                                                next;
                                        }
                                        
                                        $Value = "";
                                        $Value .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
                                        $Value .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
                                        $Value .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
                                        $Value .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
                                        $SelectorText .=  (($SelectorText ne "") ? "|" : "") . substr($Value, 1);
                                }
                                
                                $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
                                print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> $SelectorText </TD></TR>\n");
                        }
                }
        }


### FIX:: ADD SORT HERE 
        if ( $ResultCount > 0 ) {

                # Loop over each entry in the hits list
                foreach $SearchResult ( @SearchResults ) {
                        
                        # Parse the headline, also get the first document item/type
                        ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);

                        # Skip query reports
                        if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
                                next;
                        }


                        # Put a separator between each entry    
                        if ( defined($Remainder) ) {
                                
                                if ( defined($RuleFlag) && ($RuleFlag) ) {
                                        if ( $HTML ) {
                                                print("<TR><TD COLSPAN=3><HR WIDTH=25%></TD></TR>\n");
                                        }
                                        else {
                                                print("--------------------------------------------------------------\n\n");
                                        }
                                }               
                                
                                $RuleFlag = 1;
                        }


                        # Get the summary if needed
                        if ( defined($main::ConfigurationData{'allow-summary-displays'}) && ($main::ConfigurationData{'allow-summary-displays'} eq "yes") &&
                                        ($SummaryType ne "none") ) {

                                ($Status, $Text) = MPS::GetDocument($main::MPSSession, $Database, $DocumentID, $ItemName, $MimeType);
                                
                                if ( $Status ) {
                                        
                                        # Then process for each summary type
                                        if ( $SummaryType eq "default" ) {

                                                $DatabaseSummaryFilterKey = "$main::DatabaseSummaryFilter:$Database:$ItemName:$MimeType";

                                                # Is a filter defined for this database summary filter key ?
                                                if ( defined($main::DatabaseFilters{$DatabaseSummaryFilterKey}) ) {
                                                        
                                                        # Pull in the package
                                                        require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Database"};

                                                        # Filter the document
                                                        $Value = $main::DatabaseFilters{$DatabaseSummaryFilterKey};
                                                        $DatabaseSummaryFilterFunction = \&$Value;
                                                        $Text = $DatabaseSummaryFilterFunction->($Database, $DocumentID, $ItemName, $MimeType, $Text);

                                                }

                                                # Truncate the summary to the length requested
                                                if ( defined ($Text) && ($Text ne "") ) {
                                                        
                                                        $CurrentSummaryLength = 0;
                                                        $SummaryText = "";
                                                        
                                                        # Split the document text
                                                        @Words = split(/(\W)/, $Text);

                                                        # Loop over each word
                                                        foreach $Offset ( 0..scalar(@Words) ) {
                                        
                                                                # Skip undefined words
                                                                if ( !defined($Words[$Offset]) ) {
                                                                        next;
                                                                }

                                                                # Increment and check the summary length
                                                                if ( $Words[$Offset] ne " " ) {
                                                                        
                                                                        $CurrentSummaryLength++;
                                                                        
                                                                        if ( $CurrentSummaryLength  > $SummaryLength ) {
                                                                                # Append a diaresys at the end and bail
                                                                                $SummaryText .= "...";
                                                                                last;
                                                                        }
                                                                }
                                                        
                                                                # Append the current word to the end of the summary
                                                                $SummaryText .= $Words[$Offset];
                                                        }
                                                }
                                                else {
                                                        $SummaryText = "(Document summary unavailable)";
                                                }
                                        }
                                        elsif ( $SummaryType eq "keyword" ) {
                                                
                                                # First clean up the text
                                                if ( index($Text, "\r\n") >= 0 ) {
                                                        $Text =~ s/\r//gs;
                                                }
                                                elsif ( index($Text, "\r") >= 0 ) {
                                                        $Text =~ s/\r/\n/gs;
                                                }
                                                if ( defined($main::HtmlMimeTypes{$MimeType}) ) {
                                                        if ( ($Index = index($Text, "\n\n")) >= 0 ) {
                                                                $Text = substr($Text, $Index);
                                                        }
                                                        $Text =~ s/&nbsp;//gs;
                                                        $Text =~ s/<.*?>//gs;
                                                }
                                                $Text =~ s/\n/ /gs;
                                                $Text =~ s/\s+/ /gs;
                                                $Text = ucfirst($Text);
                                        
                                                # Initialize our variables
                                                $OldStart = -1;
                                                $OldEnd = -1;
                                                
                                                $Start = -1;
                                                $End = -1;

                                                $CurrentSummaryLength = 0;

                                                # Reset the offset pairs and offsets
                                                undef(@OffsetPairs);
                                                undef(%Offsets);

                                                
                                                # Split the document text
                                                @Words = split(/(\W)/, $Text);
                                                

                                                # Loop over each word, checking to see if it is in the search string hash table
                                                # and build the offset list as we go along, check with the previous offset to see
                                                # if there is an overlap
                                                foreach $Offset ( 0..scalar(@Words) ) {
                                
                                                        if ( !defined($Words[$Offset]) ) {
                                                                next;
                                                        }
                                                        
                                                        # Downcase the word
                                                        $Word = lc($Words[$Offset]);
                                                
                                                        # Very basic plural stemming
                                                        $Word =~ s/ies\Z/y/g;
                                                        $Word =~ s/s\Z//g;
                
                                                        if ( !defined($SearchStringHash{$Word}) ) {
                                                                next;
                                                        }
                                                
                                                        $Start = ($Offset < $main::SummaryKeywordSpan) ? 0 : $Offset - $main::SummaryKeywordSpan;
                                                        $End = (($Offset + $main::SummaryKeywordSpan) > (scalar(@Words) - 1)) ? (scalar(@Words) - 1) : $Offset + $main::SummaryKeywordSpan;
                                                        
                                                        if ( @OffsetPairs ) {
                                                                ($OldStart, $OldEnd) = split(/,/, $OffsetPairs[scalar(@OffsetPairs) - 1]);
                                                        }
                                                        
                                                        if ( $OldEnd >= $Start ) {
                                                                $OffsetPairs[scalar(@OffsetPairs) - 1] =  "$OldStart,$End";
                                                        }
                                                        else {
                                                                push @OffsetPairs, "$Start,$End";
                                                        }
                                                        $Offsets{$Offset} = $Offset;
                                                }
                                                
                                                
                                                # Now we rebuild the sentence from the words
                                                $SummaryText = "";
                                                foreach $OffsetPair ( @OffsetPairs ) {
                                                        
                                                        ($Start, $End) = split(/,/, $OffsetPair);
                                                
                                                        if ( $Start > 0 ) {
                                                                $SummaryText .= " ...";
                                                        }
                                                        
                                                        foreach $Offset ( $Start..$End ) {

                                                                if ( !defined($Words[$Offset]) ) {
                                                                        next;
                                                                }
                                                                
                                                                if ( defined($Offsets{$Offset}) ) {
                                                                        $SummaryText .= "<FONT COLOR=\"GREEN\">$Words[$Offset]</FONT> ";
                                                                }
                                                                else {
                                                                        $SummaryText .= $Words[$Offset] . " ";
                                                                }
                                                        
                                                                # Increment the summary length
                                                                $CurrentSummaryLength++;
                                                        }       
                                                        
                                                        # Append a diaresys at the end
                                                        if ( $End < scalar(@Words) ) {
                                                                $SummaryText .= "... ";
                                                        }

                                                        # Bail if we have reached the max summary length
                                                        if ( $CurrentSummaryLength  > $SummaryLength ) {
                                                                last;
                                                        }
                                                }
                                        }
                                }
                                else {
                                        undef($SummaryText);
                                }
                        }


                        # Decode the headline and strip the HTML
                        $Headline = &lDecodeURLData($Headline);
                        $Headline =~ s/&nbsp;//gs;
                        $Headline =~ s/<.*?>//gs;
                        $Headline =~ s/\s+/ /gs;


                        # Create the selector text
                        $SelectorText = "";
                        if ( defined($Selector) && $Selector ) {
                                $SelectorText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
                                $SelectorText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
                                $SelectorText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
                                $SelectorText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
                                $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"Document\" VALUE=\"" . substr($SelectorText, 1) . "\"> ";
                        }


                        # Put up the headline, the headline becomes the link to the document

                        # Create the link, we use the URL if it is there,
                        # otherwise we create a link from the document ID
                        if ( defined($URL) && ($URL ne "") ) {
                                $LinkText = $URL;
                        }
                        elsif ( defined($DocumentID) && ($DocumentID ne "") ) {
                                $LinkText = "";
                                $LinkText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
                                $LinkText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
                                $LinkText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
                                $LinkText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
                                $LinkText = "$ScriptName/GetDocument?" . substr($LinkText, 1);
                        }
                        else {
                                $LinkText = "";
                        }

                        # Get the mime type name
                        $MimeTypeName = (defined($main::MimeTypeNames{$MimeType})) ? $main::MimeTypeNames{$MimeType} : $MimeType;

                        # Put up the headline and the score, this one links to the document
                        if ( $HTML ) {
                                print("<!-- resultItem -->\n");
                                #print("<TR><TD ALIGN=LEFT VALIGN=TOP WIDTH=1%> $SelectorText </TD> <TD ALIGN=LEFT VALIGN=TOP WIDTH=1%> <!-- relevance --> <B> $Score </B> <!-- /relevance --> </TD> <TD ALIGN=LEFT VALIGN=TOP> <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline <I> ( $main::DatabaseDescriptions{$Database} ) </I> </A> <BR> <FONT SIZE=-2>");
                                # decode some basic html from headline <b> <i>
                                $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;

                                print("<TR><TD ALIGN=LEFT VALIGN=TOP WIDTH=1%> $SelectorText </TD><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline </A> <BR> <FONT SIZE=-2>&nbsp;");
                        } else {
                                printf("%3d $Headline \n", $Score);
                        }

if (0) { ## don't display description

                        # Put up the summary
                        if ( defined($SummaryText) && ($SummaryText ne "") ) {
                                if ( $HTML ) {
                                        print(" <I> $SummaryText </I><BR>\n");
                                }
                                else {
                                        print("    $SummaryText\n");
                                }
                        }
                        

                        # Put up the mime type name
                        if ( ! defined($Remainder) ) {
                                if ( $HTML ) {
                                        print("Formatttt: $MimeTypeName, ");
                        
                                }
                                else {
                                        print("    Format: $MimeTypeName, ");
                                }
                        }


                        # Put up the date if we got it
                         if ( defined($Date) && ($Date ne "") ) {
                                print("Date: $Date");
                                
                                # Put up the time if we got it
                                 if ( defined($Time) && ($Time ne "") ) {
                                        print(" $Time");
                                }
                                
                                print(", ");
                        }
                        
                        
                        # Put up the document size, remember that there is only one 
                        # item name/mime type for this document if the remainder is undefined
                        if ( ! defined($Remainder) ) {
                                # Put up the length if it is defined
                                if ( defined($Length) && ($Length ne "") ) {
                                        print("Size: $Length, ");
                                }
                                
                                # Put up the link
                                if ( $HTML ) {
                                        if ( defined($URL) && ($URL ne "") ) {
                                                $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
                                                print("<A HREF=\"$URL\"> $Value </A>\n");
                                        }
                                }
                                else {
                                        print("    URL: $LinkText\n");
                                }

                                # Finish off the entry
                                if ( $HTML ) {
                                        print("</FONT></TD></TR>");
                                        print("<!-- /resultItem -->\n");
                                }
                                print("\n");
                        }
                        else {
                                
                                # There is a remainder, so there is more than one item name/mime type for this document,
                                # the item names/mime types are listed as an un-numbered list
                                if ( $HTML ) {
                                        print("<UL>");
                                }
                                print("\n");
                                
                                # Set the last item to an empty string, this is also used as a flag
                                $LastItemName = "";
                                
                                # Loop while there are item names/mime types to be parsed
                                do {
                                
                                        # Get the next item name/mime type if the last item is set
                                        if ( $LastItemName ne "" ) {
                                                ($ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $Remainder, 5);
                                        }
                                        
                                        
                                        # If the item name has changed, so we close of the current list and start a new one
                                        if ( $ItemName ne $LastItemName ) {
                                                if ( $LastItemName ne "" ) {
                                                        if ( $HTML ) {
                                                                print("</UL>");
                                                        }
                                                        print("\n");
                                                }
                                                $Value = ucfirst($ItemName);
                                                if ( $HTML ) {
                                                        print("<LI> $Value </LI>\n<UL>\n");
                                                }
                                                else {
                                                        print("$Value\n");
                                                }
                                                
                                                # Set the last item name
                                                $LastItemName = $ItemName;
                                        }
                                        
                                        
                                        # Create the link, we use the URL if it is there,
                                        # otherwise we create a link from the document ID
                                        if ( defined($URL) && ($URL ne "") ) {
                                                $LinkText = $URL;
                                        }
                                        elsif ( defined($DocumentID) && ($DocumentID ne "") ) {
                                                $LinkText = "";
                                                $LinkText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
                                                $LinkText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
                                                $LinkText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
                                                $LinkText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
                                                $LinkText = "$ScriptName/GetDocument?" . substr($LinkText, 1);
                                        }
                                        else {
                                                $LinkText = "";
                                        }


                                        # Get the mime type name
                                        $MimeTypeName = defined($main::MimeTypeNames{$MimeType}) ? $main::MimeTypeNames{$MimeType} : $MimeType;
                                                

                                        # Put up the mime type, this one links to the document
                                        if ( $HTML ) {
                                                print("<LI><A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $MimeTypeName </A>");
                                        }
                                        else {
                                                print("$MimeTypeName ");
                                        }                               
                                        
                                        # Put up the length if it is defined
                                        if ( defined($Length) && ($Length ne "") ) {
                                                print("Size: $Length, ");
                                        }
                                        
                                        if ( $HTML ) {
                                                if ( defined($URL) && ($URL ne "") ) {
                                                        $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
                                                        print("<A HREF=\"$URL\"> $Value </A>\n");
                                                }
                                                print("</LI>\n");
                                        }
                                        else {
                                                print("URL: $LinkText\n");
                                        }
                                        
                                        
                                } while ( defined($Remainder) );        # Keep looping while there are item names/mime types to process
                                
                                # Close off both un-numbered  lists
                                if ( $HTML ) {
                                        print("</UL></UL>");
                                }
                                print("\n");

} #if
                                # Finish off the entry
                                if ( $HTML ) {
                                        print("</FONT></TD></TR>\n");
                                        print("<!-- /resultItem -->\n");
                                }
                        }
                }
        }


        # Print up the query report if it is defined
        if ( defined($FinalQueryReport) && ($FinalQueryReport ne "") ) {
                
                if ( $ResultCount > 0 ) {
                        if ( $HTML ) {
                                print("<TR><TD COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
                        }
                        else {
                                print("--------------------------------------------------------------\n\n");
                        }
                }

                if ( $HTML ) {
                        print("<TR><TD COLSPAN=2></TD><TD ALIGN=LEFT VALIGN=TOP>\n");
                }
        
                $Value = $FinalQueryReport;
                if ( $HTML ) {
                        $Value =~ s/\n/\<BR\>\n/g;
                }

                if ( $HTML ) {
                        print("<SMALL>\n");
                }
                
                print("$Value");
                
                if ( $HTML ) {
                        print("</SMALL>\n");
                        print("</TD></TR>\n");
                }
        }

        
        if ( $HTML ) {

                # Close off the table
                print("<!-- /searchResults -->\n");
                print("</TABLE>\n");

                if ( $Header ) {
                        # Close off the form
                        print("</FORM>\n");
                }
        }

        # Return the status and the query report
        return (1, $FinalQueryReport);

}


#--------------------------------------------------------------------------
#
#       Function:       vGetSearch()
#
#       Purpose:        This function displays a search form to the user
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData, $main::RemoteUser
#
#       Returns:        void
#
sub vGetSearch {

        my (@ItemList, $ItemEntry, $Flag);
        my ($DatabaseName, $SelectedDatabases, $Year);
        my ($Value, %Value);


        # If we are getting the default search, we check to see if there is a
        # user name defined and if they chose to have a default search
        if ( $ENV{'PATH_INFO'} eq "/GetSearch" ) {
                
                if ( defined($main::RemoteUser) && defined($main::UserSettingsFilePath) ) {
                        
                        # Get the default search symbol
                        $Value = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "DefaultSearch");
                        
                        # Set the default search
                        if ( defined($Value) && ($Value eq "Simple") ) {
                                $ENV{'PATH_INFO'} = "/GetSimpleSearch";
                        }
                        elsif ( defined($Value) && ($Value eq "Expanded") ) {
                                $ENV{'PATH_INFO'} = "/GetExpandedSearch";
                        }
                }
        
                # Override the default search if there is field from the expanded form defined 
                foreach $Value ('FieldContent3', 'Past', 'Since', 'Before') {
                        if ( defined($main::FormData{$Value}) ) {
                                $ENV{'PATH_INFO'} = "/GetExpandedSearch";
                                last;
                        }
                }
        }


        # Make sure that we send the header
        $Value = ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ? "Slo¾eno pretra¾ivanje" : "Jednostavno pretra¾ivanje";

        &vSendHTMLHeader($Value, $main::JavaScript_SetChecked);

        undef(%Value);
        $Value{'GetSearch'} = "GetSearch";
        &vSendMenuBar(%Value);
        undef(%Value);


        # Print the header ($Value is reused from the header)
        print("<H3>$Value:</H3>\n");


        # We now have a list of valid databases, at least we think so,
        # we check that there is at least one and put up an error message if there are none
        if ( scalar(keys(%main::DatabaseDescriptions)) <= 0 ) {
                &vHandleError("Database Search", "Sorry, there were no valid databases available for searching");
                goto bailFromGetSearch;
        }
        

        # Start the search form table
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

        # Display the collapse and expand buttons
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2>\n");
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
        
        # List the hidden fields
        %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
        foreach $Value ( keys(%Value) ) {
                @ItemList = split(/\0/, $Value{$Value});
                foreach $ItemEntry ( @ItemList ) {
                        print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ItemEntry\">\n");
                }
        }

        if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
                print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSimpleSearch\">\n");
                print("<INPUT SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'collapse'}\" BORDER=0 TYPE=IMAGE> Jednostavno pretra¾ivanje (kliknite na trokutiæ)\n");
        }
        else {
                print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetExpandedSearch\">\n");
                print("<INPUT SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'expand'}\" BORDER=0 TYPE=IMAGE> Slo¾eno pretra¾ivanje (kliknite na trokutiæ)\n");
        }
        print("</FORM></TD>\n");
        
        
        # Send the start of the form and the buttons
        print("<TD ALIGN=RIGHT VALIGN=TOP>\n");
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/GetSearchResults\" NAME=\"Search\" METHOD=POST> <INPUT TYPE=SUBMIT VALUE=\"Pretra¾i bazu\"> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\">\n");
        print("</TD></TR>\n");

        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><BR></TD></TR>\n");

        # Send the standard fields
        $Value = defined($main::FormData{'Any'}) ? "VALUE='$main::FormData{'Any'}'" : "";
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Pretra¾i u bilo kojem polju: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"Any\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
        
        
        my $nr_fields = $main::NormalSearchDropdowns;
        my @SearchFieldNames = @main::NormalSearchFieldNames;

        if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
                $nr_fields = $main::AdvancedSearchDropdowns;
                @SearchFieldNames = @main::AdvancedSearchFieldNames;
        }

        for (my $field=1; $field<= $nr_fields; $field++) {

                print "<TR>";
                if ($field == 1 ) {
                        print "<TD ALIGN=LEFT VALIGN=TOP ROWSPAN=$nr_fields>";
                        print "Pretra¾i u odabranom polju:";
                        print "</td>";
                }
                print ("<TD ALIGN=RIGHT VALIGN=TOP>");

                print ("<SELECT NAME=\"FieldName${field}\">");
                for (my $i=0; $i<=$#SearchFieldNames; $i++) {
                        my $ItemEntry = $SearchFieldNames[$i];
                        my $Selected = "";
                        if ($main::FormData{"FieldName${field}"} && $main::FormData{"FieldName${field}"} eq $ItemEntry) {
                                $Selected = "SELECTED";
                        } elsif ($i == ($field - 1)) {
                                $Selected = "SELECTED";
                        }
                        print("<OPTION VALUE=\"$ItemEntry\" $Selected> $main::SearchFieldDescriptions{$ItemEntry}\n");
                }
                my $Value = "";
                if (defined($main::FormData{"FieldContent${field}"})) {
                        $Value = "VALUE='".$main::FormData{"FieldContent${field}"}."'";
                }
                print("</SELECT></TD><TD ALIGN=LEFT VALIGN=TOP><INPUT NAME=\"FieldContent${field}\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
        }


        # Send a pull-down which allows the user to select what to search for
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Tra¾eni zapis mora sadr¾avati: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Operator\">\n");
        $Value = (defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "ADJ")) ? "SELECTED" : "";
        print("<OPTION VALUE=\"ADJ\"> Toènu frazu\n");
        $Value = ((defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "AND")) || !defined($main::FormData{'Operator'})) ? "SELECTED" : "";
        print("<OPTION VALUE=\"AND\" $Value> Sve rijeèi (AND)\n");
        $Value = (defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "OR")) ? "SELECTED" : "";
        print("<OPTION VALUE=\"OR\" $Value> Bilo koju rijeè (OR)\n");
        print("</SELECT> </TD></TR>\n");


        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
        

        # Database selection
        if ( %main::DatabaseDescriptions ) {

                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Odaberite knji¾nicu èiji fond ¾elite pretra¾ivati:</TD></TR>
                <TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=4>
                ");
                
                # Parse out the database names and put them into a
                # hash table, they should be separated with a '\0'
                undef(%Value);
                if ( defined($main::FormData{'Database'}) ) {
                        @ItemList = split(/\0/, $main::FormData{'Database'});
                }
                else {
                        $SelectedDatabases = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SelectedDatabases");
                        if ( defined($SelectedDatabases) ) {
                                @ItemList = split(",", $SelectedDatabases);
                        }
                }

                &ShowDatabaseCheckBoxes(@ItemList);

                print("</TD></TR>\n");
                
                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
        }


        # Print out the RF documents
        if ( defined($main::FormData{'RfDocument'}) ) {
                print("<TR>\n");
                &bDisplayDocuments("Feedback Document", $main::FormData{'RfDocument'}, "RfDocument", 1, 1, 1);
                print("</TR>\n");
                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
        }

        
        # Send complex search pull-downs
        if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {

                if ($main::ConfigurationData{'show-past-date-list'} eq 'yes') {

                        # Send the past date list
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Ogranièi na knjige koje su izdane u zadnjih : </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Past\">\n");
                        $Value = (!defined($main::FormData{'Past'})) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
                        foreach $ItemEntry ( @main::PastDate ) {
                                $Value = (defined($main::FormData{'Past'}) && ($main::FormData{'Past'} eq $ItemEntry)) ? "SELECTED" : "";
                                print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
                        }
                        print("</SELECT> </TD></TR>\n");
                }


                # Send the start date
                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Ogranièi na knjige izdane od godine: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Since\">\n");
                $Value = (!defined($main::FormData{'Since'})) ? "SELECTED" : "";
                print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
                
                $Year = (localtime)[5] + 1900;

                while ( $Year >= $main::ConfigurationData{'lowest-year'} ) {
                        $Value = (defined($main::FormData{'Since'}) && ($main::FormData{'Since'} eq $Year)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$Year\" $Value> $Year \n");
                        $Year--;
                }
                print("</SELECT> </TD></TR>\n");


                # Send the end date
                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Ogranièi na knjige izdane prije godine: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Before\">\n");
                $Value = (!defined($main::FormData{'Before'})) ? "SELECTED" : "";
                print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
                
                $Year = (localtime)[5] + 1900;

                while ( $Year >= $main::ConfigurationData{'lowest-year'} ) {
                        $Value = (defined($main::FormData{'Before'}) && ($main::FormData{'Before'} eq $Year)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$Year\" $Value> $Year \n");
                        $Year--;
                }
                print("</SELECT> </TD></TR>\n");

                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
        }
                
                        
        # Send a pull-down which allows the user to select the max number of documents
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Maksimalan broj rezultata pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Max\">\n");
        
        foreach $ItemEntry ( @main::MaxDocs ) {
                $Value = ((defined($main::FormData{'Max'}) && ($main::FormData{'Max'} eq $ItemEntry)) || (!defined($main::FormData{'Max'}) && ($ItemEntry eq $main::DefaultMaxDoc)) ) ? "SELECTED" : "";
                if ( ($ItemEntry >= 500) && $ENV{'PATH_INFO'} ne "/GetExpandedSearch" ) {
                        next;
                }
                print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
        }               

        print("</SELECT> </TD></TR>\n");


        # Send a pull-down which allows the user to select the sort order
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Sortiranje rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Order\">\n");
#       print("<OPTION VALUE=\"\"> Relevance\n");
        $Value = (defined($main::FormData{'Order'}) && ($main::FormData{'Order'} eq "SORT:DATE:DESC")) ? "SELECTED" : "";
        print("<OPTION VALUE=\"SORT:DATE:DESC\" $Value> Datum - najprije novije\n");
        $Value = (defined($main::FormData{'Order'}) && ($main::FormData{'Order'} eq "DATEASCSORT")) ? "SELECTED" : "";
        print("<OPTION VALUE=\"SORT:DATE:ASC\" $Value> Datum - najprije starije\n");
### FIX:: SORT
#       print("<OPTION VALUE=\"SORT:700+:DESC\"> autor\n");
#       print("<OPTION VALUE=\"SORT:200+:DESC\"> naslov\n");
        print("</SELECT> </TD></TR>\n");


        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
        print("<TR><TD ALIGN=RIGHT COLSPAN=3><INPUT TYPE=SUBMIT VALUE=\"Pretra¾i bazu\"> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\"></TD></TR>\n");

        print("</FORM>\n");
        print("</TABLE>\n");
        

        # Bail from the search
        bailFromGetSearch:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        $Value{'GetSearch'} = "GetSearch";
        &vSendMenuBar(%Value);
        undef(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetSearchResults()
#
#       Purpose:        This function run the search and displays the results to the user
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData, $main::RemoteUser
#
#       Returns:        void
#
sub vGetSearchResults {

        my (%Databases, $Databases, $SearchString, $SearchAndRfDocumentURL, $RfText);
        my ($Status, $DocumentText, $SearchResults, $QueryReport, $ErrorNumber, $ErrorMessage);
        my ($DatabaseRelevanceFeedbackFilterKey, $DatabaseRelevanceFeedbackFilterFunction);
        my (@Values, %Value, $Value);


        # Check to see if there are any documents selected, if there are, they need
        # to be converted to RF documents before we put up the header, this is because
        # the header creates a search link from existing search fields, we also deduplicate
        # documents along the way
        if ( defined($main::FormData{'RfDocument'}) || defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) {

                # Undefine the hash table in preparation
                undef(%Value);

                # Make a hash table from the documents already selected for feedback
                if ( defined($main::FormData{'RfDocument'}) ) {
                        foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
                                $Value{$Value} = $Value;
                        }
                }

                # Add document that were specifically selected
                if ( defined($main::FormData{'Document'}) ) {
                        foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                $Value{$Value} = $Value;
                        }
                }
                # Otherwise add documents that were selected by default
                elsif ( defined($main::FormData{'Documents'}) ) {
                        foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
                                $Value{$Value} = $Value;
                        }
                }

                # Assemble the new content
                $main::FormData{'RfDocument'} = join("\0", keys(%Value));
                
                # Delete the old content
                delete($main::FormData{'Document'});
                delete($main::FormData{'Documents'});
        }


        # Set the database names if needed
        if ( !defined($main::FormData{'Database'}) && defined($main::FormData{'RfDocument'}) ) {
                
                # Loop over each entry in the documents list
                foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
                        
                        # Parse out the document entry
                        %Value = &hParseURLIntoHashTable($Value);
                        
                        # Add the database name to the hash table
                        $Databases{$Value{'Database'}} = $Value{'Database'};
                }
                
                $main::FormData{'Database'} = join("\0", keys(%Databases));
        }


        # Make sure that we send the header
        &vSendHTMLHeader("Rezultati pretra¾ivanja", undef);
        undef(%Value);
        &vSendMenuBar(%Value);


        # Check that at least one database was selected
        if ( !defined($main::FormData{'Database'}) ) {
                print("<H3>Pretra¾ivanje baza:</H3>\n");
                print("<H3><CENTER>Niste odabrali knji¾nicu koju ¾elite pretra¾ivati.</CENTER></H3>\n");
                print("<P>\n");
                print("Potrebno je da barem jedna knji¾nica bude odabrana, kako biste mogli pretra¾ivati.\n");
                print("Kliknite na <B>'back'</B> u svom browseru, odaberite barem jednu knji¾nicu i poku¹ajte ponovo.\n");
                goto bailFromGetSearchResults;
        }


        # Extract the search information
        foreach $Value ( 1..100 ) {
        
                my ($FieldName) = "FieldName" . $Value;
                my ($FieldContent) = "FieldContent" . $Value;
                
                if ( defined($main::FormData{$FieldName}) ) {
                        if ( defined($main::FormData{$FieldContent}) && ($main::FormData{$FieldContent} ne "") ) {
                                $main::FormData{$main::FormData{$FieldName}} = $main::FormData{$FieldContent};
                        }
                }
        }


        # Set the local database names 
        if ( defined($main::FormData{'Database'}) ) {
                $Databases = $main::FormData{'Database'};
        }


        # Convert all the '\0' to ','
        $Databases =~ tr/\0/,/;
        

        # Add the max doc restriction
        if ( !defined($main::FormData{'Max'}) ) {
                $main::FormData{'Max'} = $main::DefaultMaxDoc;
        }

        
        # Generate the search string
        $SearchString = &sMakeSearchString(%main::FormData);

        # Retrieve the relevance feedback documents
        if ( defined($main::FormData{'RfDocument'}) ) {
                
                $RfText = "";
                
                # Loop over each entry in the documents list
                foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
                        
                        # Parse out the document entry
                        %Value = &hParseURLIntoHashTable($Value);
                        
                        # Check this document can be used for relevance feedback
                        if ( !defined($main::RFMimeTypes{$Value{'MimeType'}}) ) {
                                next;
                        }
                        
                        # Get the document
                        ($Status, $DocumentText) = MPS::GetDocument($main::MPSSession, $Value{'Database'}, $Value{'DocumentID'}, $Value{'ItemName'}, $Value{'MimeType'});
        
                        if ( $Status ) {

                                $DatabaseRelevanceFeedbackFilterKey = "$main::DatabaseRelevanceFeedbackFilter:$Value{'Database'}:$Value{'ItemName'}:$Value{'MimeType'}";

                                # Is a filter defined for this database relevance feedback filter key ?
                                if ( defined($main::DatabaseFilters{$DatabaseRelevanceFeedbackFilterKey}) ) {
                                        
                                        # Pull in the package
                                        require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Value{'Database'}"};

                                        # Filter the document
                                        $Value = $main::DatabaseFilters{$DatabaseRelevanceFeedbackFilterKey};
                                        $DatabaseRelevanceFeedbackFilterFunction = \&$Value;
                                        $DocumentText = $DatabaseRelevanceFeedbackFilterFunction->($Value{'Database'}, $Value{'DocumentID'}, $Value{'ItemName'}, $Value{'MimeType'}, $DocumentText);

                                }
                                else {

                                        # Strip the HTML from the text (this is only really useful on HTML documents)
                                        if ( defined($main::HtmlMimeTypes{$Value{'MimeType'}}) ) {
                                                $DocumentText =~ s/&nbsp;//gs;
                                                $DocumentText =~ s/<.*?>//gs;
                                        }
                                }

                                $RfText .= $DocumentText . " ";
                        }
                }
        }


        # Run the search
        ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Databases, $SearchString, $RfText, 0, $main::FormData{'Max'} - 1, $main::ConfigurationData{'max-score'});

        if ( $Status ) {
                
                # Display the search results and get the query report text
                ($Status, $QueryReport) = &bsDisplaySearchResults("Rezultati pretra¾ivanja:", undef, undef, undef, $SearchResults, undef, $ENV{'SCRIPT_NAME'}, 1, 1, 1, %main::FormData);
        
                # Save the search history
                if ( defined($main::RemoteUser) ) {
                        
                        # Generate the search string
                        $SearchAndRfDocumentURL = &sMakeSearchAndRfDocumentURL(%main::FormData);

                        # Save the search history
                        &iSaveSearchHistory(undef, $SearchAndRfDocumentURL, $SearchResults, $QueryReport);
                        
                        # Purge the search history files
                        &vPurgeSearchHistory;
                }
        }
        else {
                ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
                &vHandleError("Database Search", "Sorry, failed to search the database(s)");
                print("The following error message was reported: <BR>\n");
                print("Error Message: $ErrorMessage <BR>\n");
                print("Error Number: $ErrorNumber <BR>\n");
                goto bailFromGetSearchResults;
        }


        # Bail from the search
        bailFromGetSearchResults:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetDatabaseInfo()
#
#       Purpose:        This function allows the user to get some database information
#                               such as the description, the contents and the time period spanned
#                               by the content.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData
#
#       Returns:        void
#
sub vGetDatabaseInfo {

        my ($DatabaseDescription, $DatabaseLanguage, $DatabaseTokenizer, $DocumentCount, $TotalWordCount, $UniqueWordCount, $StopWordCount, $AccessControl, $UpdateFrequency, $LastUpdateDate, $LastUpdateTime, $CaseSensitive);
        my ($FieldInformation, $FieldName, $FieldDescription);
        my ($Status, $Text, $Time, $Title);
        my ($ErrorNumber, $ErrorMessage);
        my ($Value, %Value);


        # Check we that we got a database name
        if ( !defined($main::FormData{'Database'}) ) {
                &vHandleError("Database information", "Sorry, the database content description could not be obtained");
                goto bailFromGetDatabaseInfo;
        }


        # Make sure that we send the header
        $Title = "Database Information: " . (defined($main::DatabaseDescriptions{$main::FormData{'Database'}}) 
                        ? $main::DatabaseDescriptions{$main::FormData{'Database'}} : "");
        &vSendHTMLHeader($Title, undef);
        undef(%Value);
        &vSendMenuBar(%Value);


        # Get the database information
        ($Status, $Text) = MPS::GetDatabaseInfo($main::MPSSession, $main::FormData{'Database'});

        if ( $Status ) {
                
                # Display the database information
                print("<H3>Database information:</H3>\n");
        
                print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
        
        
                # Send the database description
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Database description: </TD> <TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> $main::DatabaseDescriptions{$main::FormData{'Database'}} </TD></TR>\n");
                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");

                # Truncate the line
                chop ($Text);
                                
                # Parse the database information
                ($DatabaseDescription, $DatabaseLanguage, $DatabaseTokenizer, $DocumentCount, $TotalWordCount, $UniqueWordCount, $StopWordCount, $AccessControl, $UpdateFrequency, $LastUpdateDate, $LastUpdateTime, $CaseSensitive) = split(/\t/, $Text);
                
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Database information: </TD><TD ALIGN=LEFT VALIGN=TOP> Broj rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> $DocumentCount </TD></TR>\n");
                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Total number of words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $TotalWordCount </TD></TR>\n");
                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Number of unique words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $UniqueWordCount </TD></TR>\n");
                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Number of stop words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $StopWordCount </TD></TR>\n");

                # Get the time of last update of the data directory
#               $Time = (stat("$main::ConfigurationData{'data-directory'}/$main::FormData{'Database'}/"))[9];
#               $Value = &sGetPrintableDateFromTime($Time);
#               print("<TR><TD ALIGN=LEFT VALIGN=TOP> Data last updated on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");

                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Index last updated on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $LastUpdateDate ($LastUpdateTime) </TD></TR>\n");

                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");

                # Get the database field information
                ($Status, $Text) = MPS::GetDatabaseFieldInfo($main::MPSSession, $main::FormData{'Database'});

                if ( $Status ) {
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Database Field Information: </TD> <TD ALIGN=LEFT VALIGN=TOP> Field Name: </TD> <TD ALIGN=LEFT VALIGN=TOP> Field Description: </TD></TR> \n");
        
                        foreach $FieldInformation ( split(/\n/, $Text) ) {
                                ($FieldName, $FieldDescription, $Value) = split(/\t/, $FieldInformation, 3);
                                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> $FieldName </TD> <TD ALIGN=LEFT VALIGN=TOP> $FieldDescription </TD></TR>\n");
                        }
                }
                
                print("</TABLE>\n");

        }
        else {
                ($ErrorNumber, $ErrorMessage) = split(/\t/, $Text, 2);
                &vHandleError("Database information", "Sorry, failed to get the database information");
                print("The following error message was reported: <BR>\n");
                print("Error Message: $ErrorMessage <BR>\n");
                print("Error Number: $ErrorNumber <BR>\n");
                goto bailFromGetDatabaseInfo;
        }

        
        # Bail from the database info
        bailFromGetDatabaseInfo:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetDocument()
#
#       Purpose:        This function get a document from the database.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::FooterSent
#
#       Returns:        void
#
sub vGetDocument {

        my (@DocumentList, %Document, $Document, $TextDocumentFlag);
        my ($Status, $Data, $ErrorNumber, $ErrorMessage);
        my (%QualifiedDocumentFolders, $QualifiedDocumentFolders, $FolderName, $DocumentFolderEntry);
        my ($DatabaseDocumentFilterFunction, $DatabaseDocumentFilterKey);
        my ($SelectorText, $FilteredData, $SimilarDocuments, $SearchResults);
        my (%Value, $Value);
        

        # Assemble the documents selected into a list do that we keep their order
        if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) || defined($main::FormData{'DocumentID'}) ) {

                # Undefine the hash table in preparation
                undef(%Value);

                # Add document that were specifically selected
                if ( defined($main::FormData{'Document'}) ) {
                        foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                if ( !defined($Value{$Value}) ) {
                                        push @DocumentList, $Value;
                                        $Value{$Value} = $Value;
                                }
                        }
                }
                # Otherwise add documents that were selected by default
                elsif ( defined($main::FormData{'Documents'}) ) {
                        foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
                                if ( !defined($Value{$Value}) ) {
                                        push @DocumentList, $Value;
                                        $Value{$Value} = $Value;
                                }
                        }
                }

                # Add document from the URL
                if ( defined($main::FormData{'DocumentID'}) ) {
                        $Value = "";
                        $Value .= (defined($main::FormData{'Database'}) && ($main::FormData{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($main::FormData{'Database'}) : "";
                        $Value .= (defined($main::FormData{'DocumentID'}) && ($main::FormData{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($main::FormData{'DocumentID'}) : "";
                        $Value .= (defined($main::FormData{'ItemName'}) && ($main::FormData{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($main::FormData{'ItemName'}) : "";
                        $Value .= (defined($main::FormData{'MimeType'}) && ($main::FormData{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($main::FormData{'MimeType'}) : "";
                        if ( !defined($Value{$Value}) ) {
                                push @DocumentList, $Value;
                                $Value{$Value} = $Value;
                        }
                }
        }
        

        # Catch no document selection
        if ( !@DocumentList || (scalar(@DocumentList) == 0) ) {
        
                # Make sure that we send the header
                if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
                        &vSendHTMLHeader("Similar Documents", undef);
                }
                else {
                        &vSendHTMLHeader("Documents", undef);
                }
                undef(%Value);
                &vSendMenuBar(%Value);

                print("<H3>Document retrieval:</H3>\n");
                print("<H3><CENTER>Sorry, no document(s) were selected for retrieval.</CENTER></H3>\n");
                print("<P>\n");
                print("There needs to be a least one document selected in order to perform the retrieval.\n");
                print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
                goto bailFromGetDocument;
        }


        # Set the text document flag
        $TextDocumentFlag = 0;

        # Check the documents for text based documents
        foreach $Document ( @DocumentList ) {
                
                # Parse out the document entry
                %Document = &hParseURLIntoHashTable($Document);
                
                # Set the text flag if there are any text documents in the list
                if ( $Document{'MimeType'} =~ /^text\// ) {
                        $TextDocumentFlag = 1;
                }
        }


        # If there were no text documents in our list, we display the first document in the
        # list, this is to handle cases where got one or more non-text documents (such as
        # images, pdf files, etc)
        if ( ! $TextDocumentFlag ) {
                
                %Document = &hParseURLIntoHashTable($DocumentList[0]);
        
                # Get the document
                ($Status, $Data) = MPS::GetDocument($main::MPSSession, $Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'});

                if ( !$Status ) {
                
                        # Make sure that we send the header
                        if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
                                &vSendHTMLHeader("Similar Documents", undef);
                        }
                        else {
                                &vSendHTMLHeader("Documents", undef);
                        }
                        undef(%Value);
                        &vSendMenuBar(%Value);

                        ($ErrorNumber, $ErrorMessage) = split(/\t/, $Data, 2);
                        # The database document could not be gotten, so we inform the user of the fact
                        &vHandleError("Document retrieval", "Sorry, the database document could not be obtained");
                        print("The following error message was reported: <BR>\n");
                        print("Error Message: $ErrorMessage <BR>\n");
                        print("Error Number: $ErrorNumber <BR>\n");
                        goto bailFromGetDocument;
                }

                # Send the content type
                print("Content-type: $Document{'MimeType'}\n\n");
                
                # Send the document
                print("$Data");
                                
                return;
        }

        
        # Make sure that we send the header
        if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
                &vSendHTMLHeader("Similar Documents", undef);
        }
        else {
                &vSendHTMLHeader("Documents", undef);
        }
        undef(%Value);
        &vSendMenuBar(%Value);


        # Print the header
        if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
                print("<H3>Similar Documents:</H3>\n");
        }
        else {
                print("<H3>Dokumenti:</H3>\n");
        }


        # Start the form
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");

        # Send the pull-down
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
        print("<TR><TD ALIGN=LEFT VALIGN=TOP>Odabranima se smatraju svi rezultati ukoliko niste uèinili nikakav dodatan odabir.</TD><TD ALIGN=RIGHT VALIGN=TOP> \n");
                
        if ( defined($main::RemoteUser) ) {
                print("<SELECT NAME=\"Action\">\n");
                if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
                        print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
                }
                if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
                        print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
                }
                if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
                        print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
                }
                print("<OPTION VALUE=\"GetSaveFolder\">Saèuvaj odabrane jedinice u novi folder\n");

                # Get the document folder hash
                %QualifiedDocumentFolders = &hGetDocumentFolders;

                for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
                        
                        $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
                
                        # Get the document folder file name and encode it
                        $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
                        $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
                        
                        print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry\">Add selected documents to the '$FolderName' document folder\n");
                }

                print("</SELECT>\n");
                print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
        }
        else {
                if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
                        print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSearchResults\">\n");
                        print("<INPUT TYPE=SUBMIT VALUE=\"Run search with documents as relevance feedback\">\n");
                }
        }

        print("</TD></TR>\n");
        print("</TABLE>\n");


        # Display the documents
        
        print("<TABLE BORDER=0 CELLPADDING=3 CELLSPACING=0 WIDTH=100%>\n");
        
        
        # Display the selector for all the documents 
        $SelectorText = "";

        foreach $Document ( @DocumentList ) {
                
                # Parse out the document entry
                %Document = &hParseURLIntoHashTable($Document);

                # Skip non-text documents
                if ( !($Document{'MimeType'} =~ /^text\//) ) {
                        next;
                }
                
                $Value = "";
                $Value .= (defined($Document{'Database'}) && ($Document{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Document{'Database'}) : "";
                $Value .= (defined($Document{'DocumentID'}) && ($Document{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Document{'DocumentID'}) : "";
                $Value .= (defined($Document{'ItemName'}) && ($Document{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($Document{'ItemName'}) : "";
                $Value .= (defined($Document{'MimeType'}) && ($Document{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($Document{'MimeType'}) : "";
                $SelectorText .=  (($SelectorText ne "") ? "|" : "") . substr($Value, 1);
        }
        
        $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
        print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> $SelectorText </TD></TR>\n");


        # Get the similar documents value
        if ( defined($main::RemoteUser) ) {
                $SimilarDocuments = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SimilarDocuments");
        }
        else {
                $SimilarDocuments = $main::DefaultSimilarDocument;
        }
        

        foreach $Document ( @DocumentList ) {
                
                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3> <HR WIDTH=50%> </TD></TR>\n");


                # Parse out the document entry
                %Document = &hParseURLIntoHashTable($Document);

                # Skip non-text documents
                if ( !($Document{'MimeType'} =~ /^text\//) ) {
                        next;
                }


                # Get the document
                ($Status, $Data) = MPS::GetDocument($main::MPSSession, $Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'});

                if ( !$Status ) {
                        ($ErrorNumber, $ErrorMessage) = split(/\t/, $Data, 2);
                        # The database document could not be gotten, so we inform the user of the fact
                        &vHandleError("Document retrieval", "Sorry, the database document could not be obtained");
                        print("The following error message was reported: <BR>\n");
                        print("Error Message: $ErrorMessage <BR>\n");
                        print("Error Number: $ErrorNumber <BR>\n");
                        goto bailFromGetDocument;
                }

                        
                # Create the database document filter key
                $DatabaseDocumentFilterKey = "$main::DatabaseDocumentFilter:$Document{'Database'}:$Document{'ItemName'}:$Document{'MimeType'}";
                        
                # Is a filter defined for this database document filter key ?
                if ( defined($main::DatabaseFilters{$DatabaseDocumentFilterKey}) ) {

                        # Pull in the package
                        require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Document{'Database'}"};
                
                        # Filter the document
                        $Value = $main::DatabaseFilters{$DatabaseDocumentFilterKey};
                        $DatabaseDocumentFilterFunction = \&$Value;
                        $FilteredData = $DatabaseDocumentFilterFunction->($Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'}, $Data);
                } else {
                # use default filter key

                        # Pull in the package
                        require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:default"};
                
                        # Filter the document
                        $Value = $main::DatabaseFilters{"$main::DatabaseDocumentFilter:default:$Document{'ItemName'}:$Document{'MimeType'}"};
                        $DatabaseDocumentFilterFunction = \&$Value;
                        $FilteredData = $DatabaseDocumentFilterFunction->($Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'}, $Data);
                }


                # Create the document selector button text
                $SelectorText = "";
                $SelectorText .= (defined($Document{'Database'}) && ($Document{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Document{'Database'}) : "";
                $SelectorText .= (defined($Document{'DocumentID'}) && ($Document{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Document{'DocumentID'}) : "";
                $SelectorText .= (defined($Document{'ItemName'}) && ($Document{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($Document{'ItemName'}) : "";
                $SelectorText .= (defined($Document{'MimeType'}) && ($Document{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($Document{'MimeType'}) : "";
                $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"Document\" VALUE=\"" . substr($SelectorText, 1) . "\"> ";


                # Send the document text
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> $SelectorText </TD> <TD ALIGN=LEFT VALIGN=TOP>$FilteredData</TD></TR>");
                if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {

                        # Get the similar documents if needed
                        if ( defined($main::ConfigurationData{'allow-similiar-search'}) && ($main::ConfigurationData{'allow-similiar-search'} eq "yes") &&
                                        defined($SimilarDocuments) ) {

                                # Run the search, discard the query report
                                ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Document{'Database'}, "{NOREPORT}", $Data, 0, $SimilarDocuments - 1, $main::ConfigurationData{'max-score'});
                
                                if ( $Status ) {
                                
                                        # Display the search result
                                        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3> <HR WIDTH=25%> </TD></TR>\n");
                                        print("<TR><TD ALIGN=LEFT VALIGN=TOP></TD> <TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> \n");
                                        print("<B>Similar Documents:</B>\n");
                                        ($Status, undef) = &bsDisplaySearchResults("Similar Documents:", undef, undef, undef, $SearchResults, undef, $ENV{'SCRIPT_NAME'}, 0, 1, 1, %main::FormData);
                                        print("</TD></TR>\n");
                                }
                                else {
                                        ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
                                        &vHandleError("Database Search", "Sorry, failed to search the database(s)");
                                        print("The following error message was reported: <BR>\n");
                                        print("Error Message: $ErrorMessage <BR>\n");
                                        print("Error Number: $ErrorNumber <BR>\n");
                                        goto bailFromGetDocument;
                                }
                        }
                }
        }       


        # Close off the form
        print("</FORM>\n");

        # Close off the table
        print("</TABLE>\n");


        # Bail from getting the document
        bailFromGetDocument:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetUserSettings()
#
#       Purpose:        This function displays a user settings form to the user
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vGetUserSettings {

        my ($UserName, $SearchHistory, $DefaultSearch, $SelectedDatabases, $EmailAddress, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SummaryType, $SummaryLength, $SimilarDocuments);
        my ($SearchHistoryCount, $HeaderName);
        my ($DatabaseName, @ItemList, $ItemEntry, $Flag);
        my ($Value, %Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("My Settings", $main::JavaScript_SetChecked);
        undef(%Value);
        $Value{'GetUserSettings'} = "GetUserSettings";
        &vSendMenuBar(%Value);
        undef(%Value);

        
        # Get information from the XML saved search file
        ($HeaderName, %Value) = &shGetHashFromXMLFile($main::UserSettingsFilePath);

        # Check the header if it is defines, delete the file if it is not valid,
        # else set the variables from the hash table contents
        if ( defined($HeaderName) ) {
                if ( $HeaderName ne "UserSettings" ) {
                        unlink($main::UserSettingsFilePath);
                }
                else {
                        $UserName = $Value{'UserName'};
                        $SearchHistory = $Value{'SearchHistory'};
                        $DefaultSearch = $Value{'DefaultSearch'};
                        $SelectedDatabases = $Value{'SelectedDatabases'};
                        $EmailAddress = $Value{'EmailAddress'};
                        $SearchFrequency = $Value{'SearchFrequency'};
                        $DeliveryFormat = $Value{'DeliveryFormat'};
                        $DeliveryMethod = $Value{'DeliveryMethod'};
                        $SummaryType = $Value{'SummaryType'};
                        $SummaryLength = $Value{'SummaryLength'};
                        $SimilarDocuments = $Value{'SimilarDocuments'};
                }
        }


        # Give the user a form to fill out

        print("<H3> Postavke: </H3>\n");

        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetUserSettings\" NAME=\"Search\" METHOD=POST>\n");
                
        # Send the buttons
        print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=2> <INPUT TYPE=SUBMIT VALUE=\"Saèuvaj postavke\">  <INPUT TYPE=RESET VALUE=\"Vrati poèetne vrijednosti\"> </TD></TR>\n");
        
        
        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
        
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Informacije o korisniku: </B> </TR>\n");

        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Login: </TD><TD ALIGN=LEFT VALIGN=TOP> $ENV{'REMOTE_USER'} </TD></TR>\n");

        $Value = (defined($UserName)) ? "VALUE=\"$UserName\"" : "";
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Ime korisnika: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"UserName\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");

        # Are regular searches enabled?
        if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {

                # Get the email address
                $Value = (defined($EmailAddress)) ? "VALUE=\"$EmailAddress\"" : "";
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> E-mail adresa:");
                if ( !defined($EmailAddress) && defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
                        print(" (*) ");
                }
                print(": </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"EmailAddress\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
                
                if ( !defined($EmailAddress) && defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> (*) Please fill in the email address if you are going to want to have your automatic searches delivered to you. </TD></TR>\n");
                }
        }


        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");  
        
        print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Postavke pretra¾ivanja: </B> </TD></TR>\n");

        # Send a pull-down which allows the user to select which search form to default to
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Forma za pretra¾ivanje: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DefaultSearch\">\n");
        $Value = (defined($DefaultSearch) && ($DefaultSearch eq "Simple")) ? "SELECTED" : "";
        print("<OPTION VALUE=\"Simple\" $Value>Forma za jednostavno pretra¾ivanje\n");
        $Value = (defined($DefaultSearch) && ($DefaultSearch eq "Expanded")) ? "SELECTED" : "";
        print("<OPTION VALUE=\"Expanded\" $Value>Forma za slo¾eno pretra¾ivanje\n");
        print("</SELECT> </TD></TR>\n");

        # Send a pull-down which allows the user to select how many previous searches to store
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Broj pretra¾ivanja koja ostaju zapamæena (maksimalno): </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchHistory\">\n");
        
        for ( $SearchHistoryCount = 5; $SearchHistoryCount <= 20; $SearchHistoryCount += 5 ) {
                $Value = (defined($SearchHistory) && ($SearchHistory == $SearchHistoryCount)) ? "SELECTED" : "";
                print("<OPTION VALUE=\"$SearchHistoryCount\" $Value> $SearchHistoryCount \n");
        }
        print("</SELECT> </TD></TR>\n");


        # Database selection preferences
        if ( %main::DatabaseDescriptions ) {

                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Odabrane baze: </B> </TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Oznaèite knji¾nice koje uvijek ¾elite pretra¾ivati:</TD></TR><TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2>\n");
                
                # Parse out the database names and put them into a
                # hash table, they should be separated with a '\n'
                if ( defined($SelectedDatabases) && ($SelectedDatabases ne "") ) {
                        @ItemList = split(",", $SelectedDatabases);
                }

                &ShowDatabaseCheckBoxes(@ItemList);
        
                print("</TD></TR>\n");
        }


        # Send a pull-down which allows the user to select whether to display summaries or not, and how long we want them
        if ( defined($main::ConfigurationData{'allow-summary-displays'}) && ($main::ConfigurationData{'allow-summary-displays'} eq "yes") ) {

                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Document Summary Preferences: </B> </TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Document summary type: </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SummaryType\">\n");
                foreach $ItemEntry ( keys (%main::SummaryTypes) ) {
                        $Value = (defined($SummaryType) && ($SummaryType eq $ItemEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::SummaryTypes{$ItemEntry}\n");
                }               
                print("</SELECT></TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Document summary length in words (max): </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SummaryLength\">\n");
                foreach $ItemEntry ( @main::SummaryLengths ) {
                        $Value = (defined($SummaryLength) && ($SummaryLength eq $ItemEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
                }               
                print("</SELECT></TD></TR>\n");
        }


#       print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
        
#       print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Document Retrieval Preferences: </B> </TD></TR>\n");

        # Send a pull-down which allows the user to select whether to display summaries or not, and how long we want them
        if ( defined($main::ConfigurationData{'allow-similiar-search'}) && ($main::ConfigurationData{'allow-similiar-search'} eq "yes") ) {

                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Number of similar documents retrieved (max): </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SimilarDocuments\">\n");
                foreach $ItemEntry ( @main::SimilarDocuments ) {
                        $Value = (defined($SimilarDocuments) && ($SimilarDocuments eq $ItemEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
                }               
                print("</SELECT></TD></TR>\n");
        }


        # Are regular searches enabled?
        if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {

                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Postavke saèuvanih upita: </B> </TD></TR>\n");

                # Send a pull-down which allows the user to select the automatic search frequency (default to weekly)
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Frekvencija pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
                foreach $ItemEntry ( @main::SearchFrequencies ) {
                        $Value = (defined($SearchFrequency) && ($SearchFrequency eq $ItemEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry \n");
                }
                print("</SELECT> </TD></TR>\n");

                # Send a pull-down which allows the user to select the automatic search  delivery format
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Format za isporuku rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryFormat\">\n");
                foreach $ItemEntry ( sort(keys(%main::DeliveryFormats)) ) {
                        $Value = (defined($DeliveryFormat) && ($DeliveryFormat eq  $ItemEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::DeliveryFormats{$ItemEntry}\n");
                }
                print("</SELECT> </TD></TR>\n");

                # Send a pull-down which allows the user to select the automatic delivery method
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Metoda isporuke rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
                foreach $ItemEntry ( sort(keys(%main::DeliveryMethods)) ) {
                        $Value = (defined($DeliveryMethod) && ($DeliveryMethod eq  $ItemEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::DeliveryMethods{$ItemEntry}\n");
                }
                print("</SELECT> </TD></TR>\n");
        }


        print("</FORM>\n");
        print("</TABLE>\n");
        

        # Bail from the settings
        bailFromGetUserSettings:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        $Value{'GetUserSettings'} = "GetUserSettings";
        &vSendMenuBar(%Value);
        undef(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vSetUserSettings()
#
#       Purpose:        This function saves the user setting
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vSetUserSettings {

        my (%Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("My Settings", undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        

        # Save the user settings
        undef(%Value);
        $Value{'UserName'} = $main::FormData{'UserName'};
        $Value{'EmailAddress'} = $main::FormData{'EmailAddress'};
        $Value{'DefaultSearch'} = $main::FormData{'DefaultSearch'};
        $Value{'SelectedDatabases'} = $main::FormData{'Database'};
        if ( defined($Value{'SelectedDatabases'}) ) {
                $Value{'SelectedDatabases'} =~ s/\0/,/g;
        }
        $Value{'SearchHistory'} = $main::FormData{'SearchHistory'};
        $Value{'SearchFrequency'} = $main::FormData{'SearchFrequency'};
        $Value{'DeliveryFormat'} = $main::FormData{'DeliveryFormat'};
        $Value{'DeliveryMethod'} = $main::FormData{'DeliveryMethod'};
        $Value{'SummaryType'} = $main::FormData{'SummaryType'};
        $Value{'SummaryLength'} = $main::FormData{'SummaryLength'};
        $Value{'SimilarDocuments'} = $main::FormData{'SimilarDocuments'};

        
        # Save the user settings file
        if ( &iSaveXMLFileFromHash($main::UserSettingsFilePath, "UserSettings", %Value) ) {

                print("<H3> Postavke: </H3>\n");
                print("<H3><CENTER> Postavke su uspje¹no snimljene! </CENTER></H3>\n");
                print("<P>\n");
        }
        else {

                # The settings could not be saved, so we inform the user of the fact
                &vHandleError("User Settings", "Sorry, we failed to saved your settings");
        }


        # Bail from the settings
        bailFromSetUserSettings:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);
        
        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vPurgeSearchHistory()
#
#       Purpose:        This function purges the search history files.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       $main::DefaultMaxSearchHistory, $main::UserSettingsFilePath,
#                                               $main::SearchHistoryFileNamePrefix, $main::UserAccountDirectoryPath
#
#       Returns:        void
#
sub vPurgeSearchHistory {

        my ($MaxSearchHistory, @SearchHistoryList, $SearchHistoryEntry);


        # Return if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }
        
        
        # Get the max number of entries in the search history
        $MaxSearchHistory = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SearchHistory");
        
        # Set the detault max number of entries if it was not gotten from the user settings
        if ( !defined($MaxSearchHistory) ) {
                $MaxSearchHistory = $main::DefaultMaxSearchHistory;
        }
        

        # Read all the search history files
        opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
        @SearchHistoryList = map("$main::UserAccountDirectoryPath/$_" , 
                        reverse(sort(grep(/$main::SearchHistoryFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
        closedir(USER_ACCOUNT_DIRECTORY);


        # Purge the excess search history files
        if ( scalar(@SearchHistoryList) > $MaxSearchHistory ) {
        
                # Splice out the old stuff, and loop over it deleting the files
                for $SearchHistoryEntry ( splice(@SearchHistoryList, $MaxSearchHistory) ) {
                        unlink($SearchHistoryEntry);
                }
        }

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vListSearchHistory()
#
#       Purpose:        This function lists the search history for the user, the 
#                               entries are listed in reverse chronological order (most
#                               recent first).
#
#                               In addition, the search history will be scanned and excess
#                               searches will be purged.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, $main::UserAccountDirectoryPath,
#                                               $main::XMLFileNameExtension, $main::SearchHistoryFileNamePrefix, 
#                                               $main::RemoteUser
#
#       Returns:        void
#
sub vListSearchHistory {

        my (@SearchHistoryList, @QualifiedSearchHistoryList, $SearchHistoryEntry);
        my ($SearchString, $CreationTime, $SearchAndRfDocumentURL, $HeaderName, $Database);
        my ($Value, %Value, @Values);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("Prija¹nja pretra¾ivanja", undef);
        undef(%Value);
        $Value{'ListSearchHistory'} = "ListSearchHistory";
        &vSendMenuBar(%Value);
        undef(%Value);


        # Purge the search history files
        &vPurgeSearchHistory;


        # Read all the search history files
        opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
        @SearchHistoryList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::SearchHistoryFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
        closedir(USER_ACCOUNT_DIRECTORY);


        # Loop over each search history file checking that it is valid
        for $SearchHistoryEntry ( @SearchHistoryList ) {

                # Get the header name from the XML search history file
                $HeaderName = &sGetObjectTagFromXMLFile($SearchHistoryEntry);

                # Check that the entry is valid and add it to the qualified list
                if ( defined($HeaderName) && ($HeaderName eq "SearchHistory") ) {
                        push @QualifiedSearchHistoryList, $SearchHistoryEntry;
                }
                else {
                        # Else we delete this invalid search history file
                        unlink($SearchHistoryEntry);
                }
        }


        # Display the search history 
        print("<H3> Prija¹nja pretra¾ivanja: </H3>\n");
        
        # Print up the search history, if there is none, we put up a nice message
        if ( scalar(@QualifiedSearchHistoryList) > 0 ) {
                
                print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

                
                for $SearchHistoryEntry ( @QualifiedSearchHistoryList ) {
                
                        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");

                        # Get information from the XML search history file
                        ($HeaderName, %Value) = &shGetHashFromXMLFile($SearchHistoryEntry);
                        
                        # Get the search file name and encode it
                        $SearchHistoryEntry = ($SearchHistoryEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $SearchHistoryEntry;
                        $SearchHistoryEntry = &lEncodeURLData($SearchHistoryEntry);

                        $CreationTime = $Value{'CreationTime'};
                        $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
                        %Value = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
                        $SearchString = &sMakeSearchString(%Value);
                        if ( defined($SearchString) ) {
                                $SearchString =~ s/{.*?}//gs;
                                $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
                        }
                        $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";


                        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD><TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");

                        # Get the local databases from the search and list their descriptions
                        if ( defined($Value{'Database'}) ) {
                                
                                # Initialize the temp list
                                undef(@Values);
                
                                # Loop over each database
                                foreach $Database ( split(/\0/, $Value{'Database'}) ) {
                                        $Value = &lEncodeURLData($Database);
                                        push @Values, sprintf("<A HREF=\"$ENV{'SCRIPT_NAME'}/GetDatabaseInfo?Database=$Value\" OnMouseOver=\"self.status='Informacije o bazi $main::DatabaseDescriptions{$Database}'; return true\">  $main::DatabaseDescriptions{$Database} </A> ");
                                }
                
                                # Print the list if there are any entries in it
                                if ( scalar(@Values) > 0 ) {
                                        printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD><TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n", 
                                                        scalar(@Values) > 1 ? "s" : "", join(", ", @Values));
                                }
                        }

                        if ( defined($Value{'RfDocument'}) ) {
                                print("<TR>");
                                &bDisplayDocuments("Feedback Document", $Value{'RfDocument'}, "RfDocument", undef, undef, 1);
                                print("</TR>");
                        }
                        
                        $Value = &sGetPrintableDateFromTime($CreationTime);
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD><TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");

                        print("<TR><TD ALIGN=LEFT VALIGN=TOP> </TD><TD ALIGN=LEFT VALIGN=TOP> <A HREF=\"$ENV{'SCRIPT_NAME'}/GetSearchHistory?SearchHistoryObject=$SearchHistoryEntry\" > [ Prika¾i rezultate pretra¾ivanja ] </A> </TD></TR>\n");

                }
                
                print("</TABLE>\n");
        }
        else {
                print("<H3><CENTER> Sorry, currently there is no search history. </CENTER></H3>\n");
        }


        # Bail from the search history
        bailFromListSearchHistory:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        $Value{'ListSearchHistory'} = "ListSearchHistory";
        &vSendMenuBar(%Value);
        undef(%Value);
        
        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetSearchHistory()
#
#       Purpose:        This function displays a search history file to the user.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::SearchHistoryFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vGetSearchHistory {

        my ($SearchAndRfDocumentURL, $SearchResults, $QueryReport, $CreationTime);
        my ($SearchHistoryEntry, $HeaderName, $Status);
        my ($Value, %Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Create the search history file name
        $SearchHistoryEntry = $main::UserAccountDirectoryPath . "/" . $main::FormData{'SearchHistoryObject'};


        # Check to see if the XML search history file requested is there
        if ( ! -f $SearchHistoryEntry ) {
                # Could not find the search history file
                &vHandleError("Display Search History", "Sorry, we cant to access this search history object because it is not there");
                goto bailFromGetSearchHistory;
        }


        # Get information from the XML search history file
        ($HeaderName, %Value) = &shGetHashFromXMLFile($SearchHistoryEntry);

        # Check that the entry is valid 
        if ( !(defined($HeaderName) && ($HeaderName eq "SearchHistory")) ) {
                &vHandleError("Display Search History", "Sorry, this search history object is invalid");
                goto bailFromGetSearchHistory;
        }


        # At this point, the XML search history file is there and is valid,
        # so we can go ahead and display it 
        $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
        $SearchResults = $Value{'SearchResults'};
        $QueryReport = $Value{'QueryReport'};
        $CreationTime = $Value{'CreationTime'};
        
        %main::FormData = &hParseURLIntoHashTable($SearchAndRfDocumentURL);

        # Make sure that we send the header
        &vSendHTMLHeader("Display Search History", undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        

        ($Status, $QueryReport) = &bsDisplaySearchResults("Rezultati prija¹njih pretra¾ivanja:", undef, undef, undef, $SearchResults, $QueryReport, $ENV{'SCRIPT_NAME'}, 1, 1, 1, %main::FormData);

        
        # Bail from displaying the search history
        bailFromGetSearchHistory:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetSaveSearch()
#
#       Purpose:        This function displays a form to the user allowing them to save a search
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vGetSaveSearch {


        my ($SearchString, $Database);
        my ($HeaderName, $SearchFrequency, $DeliveryFormat, $DeliveryMethod);
        my ($JavaScript, $EmailAddress);
        my ($Value, @Values, %Value, $ValueEntry);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        $JavaScript = '<SCRIPT LANGUAGE="JavaScript">
                <!-- hide
                function checkForm( Form ) {
                        if ( !checkField( Form.SearchName, "Search name" ) )
                                return false
                        return true
                }
                function checkField( Field, Name ) {
                        if ( Field.value == "" ) {
                                errMsg( Field, "Niste ispunili polje \'"+Name+"\' ." )
                                return false
                        }
                        else {
                                return true
                        }
                }
                function errMsg( Field, Msg ) {
                        alert( Msg )
                        Field.focus()
                        return
                }
                // -->
                </SCRIPT>
                ';


        # Make sure that we send the header
        &vSendHTMLHeader("Save this Search", $JavaScript);
        undef(%Value);
        &vSendMenuBar(%Value);
        

        # Give the user a form to fill out
        print("<H3> Èuvanje upita: </H3>\n");


        # Get information from the XML saved search file
        ($HeaderName, %Value) = &shGetHashFromXMLFile($main::UserSettingsFilePath);

        $SearchFrequency = $Value{'SearchFrequency'};
        $DeliveryFormat = $Value{'DeliveryFormat'};
        $DeliveryMethod = $Value{'DeliveryMethod'};
        $EmailAddress = $Value{'EmailAddress'};


        # Print up the table start
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

        # Start the form        
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetSaveSearch\" onSubmit=\"return checkForm(this)\" METHOD=POST>\n");

        # Send the buttons
        print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=2>  <INPUT TYPE=SUBMIT VALUE=\"Saèuvaj upit\"> <INPUT TYPE=RESET VALUE=\"Vrati poèetne vrijednosti\"></TD></TR>\n");

        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

        # Print up the search string
        $SearchString = &sMakeSearchString(%main::FormData);
        if ( defined($SearchString) ) {
                $SearchString =~ s/{.*?}//gs;
                $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
        }
        $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
        print("<TR><TD ALIGN=LEFT VALIGN=TOP>  Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
        
        # Get the local databases from the search and list their descriptions
        if ( defined($main::FormData{'Database'}) ) {
                
                # Initialize the temp list
                undef(@Values);
                
                foreach $Database ( sort(split(/\0/, $main::FormData{'Database'})) ) {
                        $Value = &lEncodeURLData($Database);
                        push @Values, sprintf("<A HREF=\"$ENV{'SCRIPT_NAME'}/GetDatabaseInfo?Database=$Value\" OnMouseOver=\"self.status='Get Information about the $main::DatabaseDescriptions{$Database} database'; return true\">  $main::DatabaseDescriptions{$Database} </A> ");
                }
                
                # Print the list if there are any entries in it
                if ( scalar(@Values) > 0 ) {
                        printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n", (scalar(@Values) > 1) ? "s" : "", join(", ", @Values));
                }
        }

        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

        # Send the search name and search description fields
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Naziv (obavezno): </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"SearchName\" TYPE=TEXT SIZE=45> </TD></TR>\n");

        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> <TEXTAREA INPUT NAME=\"SearchDescription\" COLS=45 ROWS=6 WRAP=VIRTUAL></TEXTAREA> </TD></TR>\n");

        if ( defined($main::FormData{'RfDocument'}) ) {
                print("<TR>\n");
                &bDisplayDocuments("Feedback Document", $main::FormData{'RfDocument'}, "RfDocument", undef, undef, 1);
                print("</TR>\n");
        }
                        

        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Kliknite na ovaj kvadratiæ ako ¾elite postojeæi upit s istim imenom zamijeniti ovim novim: </TD> <TD ALIGN=LEFT VALIGN=TOP><INPUT TYPE=\"checkbox\" NAME=\"OverWrite\" VALUE=\"yes\"> </TD></TR>\n");
        
        
        # Are regular searches enabled?
        if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
        
                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Kliknite ovaj kvadratiæ ukoliko ¾elite automatsko periodièko pretra¾ivanje po ovom upitu: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT TYPE=CHECKBOX VALUE=\"yes\" NAME=\"Regular\"> </TD></TR>\n");

                # Send a pull-down which allows the user to select the automatic search frequency
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite frekvenciju automatskog pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
                foreach $ValueEntry ( @main::SearchFrequencies ) {
                        $Value = (defined($SearchFrequency) && ($SearchFrequency eq $ValueEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ValueEntry\" $Value> $ValueEntry \n");
                }
                print("</SELECT> </TD></TR>\n");

                # Send a pull-down which allows the user to select the automatic search delivery format
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite format za isporuku rezultata pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryFormat\">\n");
                foreach $ValueEntry ( sort(keys(%main::DeliveryFormats)) ) {
                        $Value = (defined($DeliveryFormat) && ($DeliveryFormat eq  $ValueEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ValueEntry\" $Value> $main::DeliveryFormats{$ValueEntry}\n");
                }
                print("</SELECT> </TD></TR>\n");

                # Send a pull-down which allows the user to select the automatic search delivery method
                print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite metodu isporuke: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
                foreach $ValueEntry ( sort(keys(%main::DeliveryMethods)) ) {
                        $Value = (defined($DeliveryMethod) && ($DeliveryMethod eq  $ValueEntry)) ? "SELECTED" : "";
                        print("<OPTION VALUE=\"$ValueEntry\" $Value> $main::DeliveryMethods{$ValueEntry}\n");
                }
                print("</SELECT> </TD></TR>\n");
        }


        # List the hidden fields
        %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
        foreach $Value ( keys(%Value) ) {
                foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
                        print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
                }
        }

        print("</FORM>\n");
        print("</TABLE>\n");

        if ( !defined($EmailAddress) &&
                        (defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes")) ) {
                print("<CENTER><HR WIDTH=50%></CENTER>\n");
                print("<B>Note: </B> You have not specified an email address in your settings, you will need to specify it if you want to run this search on a regular basis. <P>\n");
        }


        # Bail from saving the search
        bailFromGetSaveSearch:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vSetSaveSearch()
#
#       Purpose:        This function saves that search and search name in a search file 
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vSetSaveSearch {


        my ($SearchAndRfDocumentURL, $SearchString);
        my (@SavedSearchList, $SavedSearchEntry, $SavedSearchFilePath);
        my ($EmailAddress, $SearchName, $CreationTime, $LastRunTime);
        my ($Value, %Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("Saèuvana pretra¾ivanja", undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        

        # Check that the required fields are filled in
        if ( !defined($main::FormData{'SearchName'}) ) {
                
                # A required field is missing, so we suggest corrective action to the user.
                print("<H3> Snimanje pretra¾ivanja: </H3>\n");
                print("<H3><CENTER> Oprostite, nedostaju neke informacije. </CENTER></H3>\n");
                print("<P>\n");
                print("Polje <B>'search name'</B> mora biti ispunjeno da bi se moglo saèuvati pretra¾ivanje.<P>\n");
                print("Kliknite na <B>'Back'</B> u svom browseru, popunite polje koje nedostaje i poku¹ajte ponovo.\n");
                print("<P>\n");

                goto bailFromSetSaveSearch;
        
        }


        # Read all the saved search files
        opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
        @SavedSearchList = map("$main::UserAccountDirectoryPath/$_", grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)));
        closedir(USER_ACCOUNT_DIRECTORY);


        # Loop over each saved search file checking that it is valid
        for $SavedSearchEntry ( @SavedSearchList ) {
                
                $SearchName = &sGetTagValueFromXMLFile($SavedSearchEntry, "SearchName");
                
                if ( $SearchName eq $main::FormData{'SearchName'} ) {
                        $SavedSearchFilePath = $SavedSearchEntry;
                        last;
                }
        }

        # Check that the saved search file does not already exist
        if ( defined($SavedSearchFilePath) && ($SavedSearchFilePath ne "")
                        && !(defined($main::FormData{'OverWrite'}) && ($main::FormData{'OverWrite'} eq "yes")) ) {

                # There is already a saved search with this name, so we suggest corrective action to the user.
                print("<H3> Èuvanje upita: </H3>\n");
                print("<H3><CENTER> Veæ postoji upit pod ovim imenom. </CENTER></H3>\n");
                print("<P>\n");
                print("Kliknite <B>'back'</B> u browseru, promijenite <B>'Naziv'</B> i poku¹ajte ponovo, \n");
                print("ili kliknuti na kvadratiæ koji vam omoguæava da automatski presnimite saèuvani upit s istim imenom.\n");
                print("<P>\n");

                goto bailFromSetSaveSearch;
        }
        

        # Get the email address of this user
        $Value = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
        
        # Check this user has an email address defined if they want to run the search on a regular basis
        if ( !defined($Value) && (defined($main::FormData{'Regular'}) && ($main::FormData{'Regular'} eq "yes")) ) {
                
                # Regular delivery was requested, but the email address was not specified in the settings
                print("<H3> Èuvanje upita: </H3>\n");
                print("<H3><CENTER> E-mail adresa nije specificirana u va¹im postavkama. </CENTER></H3>\n");
                print("<P>\n");
                print("Potrebno je specificirati e-mail adresu ukoliko ¾elite da se pretra¾ivanje po ovom upitu odvije periodièno. \n");
                print("bez e-mail adrese, nismo vam u moguænosti isporuèiti rezultate. <P>\n");
                print("Kliknite na <B>'Korisnièke postavke'</B>, upi¹ite e-mail adresu i saèuvajte postavke, \n");
                print("nakon toga kliknite na <B>'back'</B> u svom browseru tri puta kako biste se vratili na formu koja vam nudi da saèuvate upit.\n");
                print("<P>\n");

                goto bailFromSetSaveSearch;
        }


        # All the checks have been passed, so we can go ahead and save the search

        $CreationTime = time();
        $LastRunTime = $CreationTime;
        
        # Erase the search frequency and the delivery method if this is not a regular search
        if ( !(defined($main::FormData{'Regular'}) && ($main::FormData{'Regular'} eq "yes")) ) {
                $main::FormData{'SearchFrequency'} = "";
                $main::FormData{'DeliveryFormat'} = "";
                $main::FormData{'DeliveryMethod'} = "";
                $LastRunTime = "";
        }


        # Get the URL search string
        $SearchAndRfDocumentURL = &sMakeSearchAndRfDocumentURL(%main::FormData);

        # Save the search
        if ( &iSaveSearch(undef, $main::FormData{'SearchName'}, $main::FormData{'SearchDescription'}, $SearchAndRfDocumentURL, $main::FormData{'SearchFrequency'}, $main::FormData{'DeliveryFormat'}, $main::FormData{'DeliveryMethod'}, "Active", $CreationTime, $LastRunTime) ) {

                print("<H3> Saving a Search: </H3>\n");
                print("<P>\n");
                print("<H3><CENTER> Your search was successfully saved. </CENTER></H3>\n");
                
                # Delete the overwritten search file
                if ( defined($SavedSearchFilePath) && ($SavedSearchFilePath ne "") ) {
                        unlink($SavedSearchFilePath);
                }
        }
        else {

                # The search could not be saved, so we inform the user of the fact
                &vHandleError("Saving a Search", "Sorry, we failed to save this search");
                goto bailFromSetSaveSearch;
        }


        # Bail from saving the search
        bailFromSetSaveSearch:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vListSavedSearch()
#
#       Purpose:        This function allows the user list the saved searches and
#                               sets up the links allowing the user to get a search form
#                               filled with the search
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::SavedSearchFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vListSavedSearch {

        my (@SavedSearchList, @QualifiedSavedSearchList, $SavedSearchEntry, $HeaderName, $SearchString, $Database);
        my ($SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $LastRunTime);
        my (@Values, $Value, %Value);

        
        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("Saèuvana pretra¾ivanja", undef);
        undef(%Value);
        $Value{'ListSavedSearch'} = "ListSavedSearch";
        &vSendMenuBar(%Value);
        undef(%Value);


        # Read all the saved search files
        opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
        @SavedSearchList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
        closedir(USER_ACCOUNT_DIRECTORY);


        # Loop over each search history file checking that it is valid
        for $SavedSearchEntry ( @SavedSearchList ) {
                
                # Get the header name from the XML saved search file
                $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchEntry);

                # Check that the entry is valid and add it to the qualified list
                if ( defined($HeaderName) && ($HeaderName eq "SavedSearch") ) {
                        push @QualifiedSavedSearchList, $SavedSearchEntry;
                }
                else {
                        # Else we delete this invalid saved search file
                        unlink($SavedSearchEntry);
                }
        }


        # Print out the saved searches
        print("<H3> Saèuvani upiti: </H3>\n");
        

        # Print up the saved searches, if there is none, we put up a nice message
        if ( scalar(@QualifiedSavedSearchList) > 0 ) {
                                
                # Start the table
                print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
        
                # Start the form
                print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
                
        
                print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> \n");
                print("<SELECT NAME=\"Action\">\n");
                print("<OPTION VALUE=\"ActivateSavedSearch\">Ukljuèi periodièno automatsko pretra¾ivanje po odabranim upitima\n");
                print("<OPTION VALUE=\"SuspendSavedSearch\">Iskljuèi periodièno automatsko pretra¾ivanje po odabranim upitima\n");
                print("<OPTION VALUE=\"DeleteSavedSearch\">Obri¹i oznaèene saèuvane upite\n");
                print("</SELECT>\n");
                print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
                print("</TD></TR>\n");

                for $SavedSearchEntry ( @QualifiedSavedSearchList ) {
                
                        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");

                        # Get information from the XML saved search file
                        ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchEntry);

                        # Get the saved search file name and encode it
                        $SavedSearchEntry = ($SavedSearchEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $SavedSearchEntry;
                        $SavedSearchEntry = &lEncodeURLData($SavedSearchEntry);
                        

                        $SearchName = $Value{'SearchName'};
                        $SearchDescription = $Value{'SearchDescription'};
                        $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
                        $SearchFrequency = $Value{'SearchFrequency'};
                        $SearchStatus = $Value{'SearchStatus'};
                        $DeliveryFormat = $Value{'DeliveryFormat'};
                        $DeliveryMethod = $Value{'DeliveryMethod'};
                        $CreationTime = $Value{'CreationTime'};
                        $LastRunTime = $Value{'LastRunTime'};
                        
                        # Parse the URL Search string into a hash so that we can get at it's components
                        %Value = &hParseURLIntoHashTable($SearchAndRfDocumentURL);

                        $SearchString = &sMakeSearchString(%Value);
                        if ( defined($SearchString) ) {
                                $SearchString =~ s/{.*?}//gs;
                                $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
                        }
                        $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
                        
                        # Print the link
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP><INPUT TYPE=\"checkbox\" NAME=\"SavedSearchObject\" VALUE=\"$SavedSearchEntry\"> </TD><TD ALIGN=LEFT VALIGN=TOP> Naziv: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchName </TD></TR>\n");

                        # Print the search description
                        $SearchDescription = defined($SearchDescription) ? $SearchDescription : "(Nije naveden)";
                        $SearchDescription =~ s/\n/<BR>/g;
                        $SearchDescription =~ s/\r/<BR>/g;
                        print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDescription </TD></TR>\n");
                        
                        print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");

                        # Get the local databases from the search and list their descriptions
                        if ( defined($Value{'Database'}) ) {
                
                                # Initialize the temp list
                                undef(@Values);
                
                                # Loop over each database
                                foreach $Database ( split(/\0/, $Value{'Database'}) ) {
                                        $Value = &lEncodeURLData($Database);
                                        push @Values, sprintf("<A HREF=\"$ENV{'SCRIPT_NAME'}/GetDatabaseInfo?Database=$Value\" OnMouseOver=\"self.status='Get Information about the $main::DatabaseDescriptions{$Database} database'; return true\">  $main::DatabaseDescriptions{$Database} </A> ");
                                }
                
                                # Print the list if there are any entries in it
                                if ( scalar(@Values) > 0 ) {
                                        printf("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n", (scalar(@Values) > 1) ? "s" : "", join(", ", @Values));
                                }
                        }
                        

                        if ( defined($Value{'RfDocument'}) ) {
                                print("<TR><TD></TD>\n");
                                &bDisplayDocuments("Feedback Document", $Value{'RfDocument'}, "RfDocument", undef, undef, 1);
                                print("</TR>\n");
                        }
                        
                        undef(%Value);

                        
                        if ( defined($SearchFrequency) || defined($DeliveryFormat) || defined($DeliveryMethod) ) {
                                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP NOWRAP> Automatsko pokretanje: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchFrequency </TD></TR>\n");
                                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Format isporuke: </TD> <TD ALIGN=LEFT VALIGN=TOP> $main::DeliveryFormats{$DeliveryFormat} </TD></TR>\n");
                                print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Methoda isporuke: </TD> <TD ALIGN=LEFT VALIGN=TOP> $main::DeliveryMethods{$DeliveryMethod} </TD></TR>\n");
                        }
                        
                        $Value = &sGetPrintableDateFromTime($CreationTime);
                        print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP NOWRAP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");

                        
                        if ( defined($SearchFrequency) || defined($DeliveryFormat) || defined($DeliveryMethod) ) {

                                if ( defined($LastRunTime) ) {
                                        $Value = &sGetPrintableDateFromTime($LastRunTime);
                                        print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP NOWRAP> Zadnje pokretanje: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
                                }

                                printf("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Status: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>",
                                                (defined($SearchStatus) && ($SearchStatus eq "Active")) ? "Active" : "Suspended");

                        }
                
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP></TD><TD ALIGN=LEFT VALIGN=TOP></TD> <TD ALIGN=LEFT VALIGN=TOP> <A HREF=\"$ENV{'SCRIPT_NAME'}/GetSavedSearch?SavedSearchObject=$SavedSearchEntry\" OnMouseOver=\"self.status='Display the search form with this search'; return true\"> [ Otvori formu za pretra¾ivanje s upisanim ovim upitom ] </A> </TD></TR>\n");
                }
                
                print("</FORM></TABLE>\n");
        }
        else {
                print("<H3><CENTER> Trenutno nemate saèuvanih upita!. </CENTER></H3>\n");
        }
        
        
        # Bail from displaying saved searches
        bailFromDisplaySavedSearch:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        $Value{'ListSavedSearch'} = "ListSavedSearch";
        &vSendMenuBar(%Value);
        undef(%Value);

        &vSendHTMLFooter;


        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetSavedSearch()
#
#       Purpose:        This function gets a saved search.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::SavedSearchFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vGetSavedSearch {

        my ($HeaderName, $SavedSearchFilePath, $SearchAndRfDocumentURL, $DefaultSearch);
        my ($Value, %Value);
        
        
        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Set the saved search file path
        $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'SavedSearchObject'};


        # Check to see if the XML saved search file requested is there
        if ( ! -f $SavedSearchFilePath ) {
                # Could not find the saved search file
                &vHandleError("Prikaz saèuvaniog pretra¾ivanja", "Sorry, we cant to access this saved search object because it is not there");
                &vSendHTMLFooter;
                return;
        }


        # Get the data from the XML saved search file
        $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchFilePath);

        # Check that the entry is valid 
        if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
                &vHandleError("Prikaz saèuvaniog pretra¾ivanja", "Sorry, this saved search object is invalid");
                &vSendHTMLFooter;
                return;
        }


        # All is fine, so we hand over the hash and get the search
        %main::FormData = &hParseURLIntoHashTable(&sGetTagValueFromXMLFile($SavedSearchFilePath, 'SearchAndRfDocumentURL'));

        $ENV{'PATH_INFO'} = "/GetSearch";

        # Display the search form, it will autoset itself from %main::FormData
        &vGetSearch;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vProcessSavedSearch()
#
#       Purpose:        This function processes a saved search.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::SavedSearchFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vProcessSavedSearch {

        my ($Title, $HeaderName, $SavedSearchFilePath, $SavedSearchObject);
        my ($Value, %Value);
        
        
        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }

        
        # Set the title
        if ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
                $Title = "Brisanje saèuvanih pretra¾ivanja";
        }
        elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
                $Title = "Ukljuèivanje automatskog periodiènog pretra¾ivanja";
        }
        elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
                $Title = "Iskljuèivanje automatskog periodiènog pretra¾ivanja";
        }
        
        
        # Make sure that we send the header
        &vSendHTMLHeader($Title, undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        
        
        print("<H3> $Title: </H3>\n");

        # Check to see if the saved search object is defined
        if ( ! defined($main::FormData{'SavedSearchObject'}) ) {
                # Could not find the saved search object
                print("<H3><CENTER>Niste odabrali niti jedan upit. </CENTER></H3>\n");
                print("<P>\n");
                print("Potrebno je odabrati barem jedan saèuvani upit nad kojim æe se izvr¹iti akcija.\n");
                print("<P>\n");
                goto bailFromProcessSavedSearch;
        }

        
        # Loop over each saved search
        foreach $SavedSearchObject ( split(/\0/, $main::FormData{'SavedSearchObject'}) ) {

                # Set the saved search file path
                $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/" . $SavedSearchObject;
        
                # Check to see if the XML saved search file requested is there
                if ( ! -f $SavedSearchFilePath ) {
                        next;
                }

                # Get information from the XML saved search file
                ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchFilePath);
        
                # Check that the entry is valid 
                if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
                        next;
                }


                if ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
                        if ( unlink($SavedSearchFilePath) ) {
                                printf("<P>Uspje¹no pobrisano: %s\n", $Value{'SearchName'});
                        }
                        else {
                                printf("<P>Nije pobrisano: %s\n", $Value{'SearchName'});
                        }
                }
                elsif ( ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") || ($ENV{'PATH_INFO'} eq "/SuspendSavedSearch") ) {
                        
                        if ( !defined($Value{'SearchStatus'}) ) {
                                printf("<P>Could not %s: %s, as it is not a regular search\n", 
                                                ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "activate" : "suspend", $Value{'SearchName'});
                        }
                        else {
                        
                                $Value{'SearchStatus'} =  ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "Active" : "Inactive" ;
                                
                                if ( &iSaveXMLFileFromHash($SavedSearchFilePath, "SavedSearch", %Value) ) {
                                        printf("<P>Uspje¹no %s: %s\n", 
                                                        ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "ukljuèeno" : "iskljuèeno", $Value{'SearchName'});
                                }
                                else {
                                        printf("<P>Nije %s: %s\n", 
                                                        ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "ukljuèeno" : "iskljuèeno", $Value{'SearchName'});
                                }
                        }
                }
        }

        print("<P>\n");

        # Bail from processing the saved search
        bailFromProcessSavedSearch:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetSaveFolder()
#
#       Purpose:        This function displays a form to the user allowing them to 
#                               save documents to a folder
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vGetSaveFolder {


        my ($JavaScript);
        my ($Value, @Values, %Value, $ValueEntry);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        $JavaScript = '<SCRIPT LANGUAGE="JavaScript">
                <!-- hide
                function checkForm( Form ) {
                        if ( !checkField( Form.FolderName, "Folder name" ) )
                                return false
                        return true
                }
                function checkField( Field, Name ) {
                        if ( Field.value == "" ) {
                                errMsg( Field, "Niste ispunili polje \'"+Name+"\'." )
                                return false
                        }
                        else {
                                return true
                        }
                }
                function errMsg( Field, Msg ) {
                        alert( Msg )
                        Field.focus()
                        return
                }
                // -->
                </SCRIPT>
                ';


        # Make sure that we send the header
        &vSendHTMLHeader("Saving a Document Folder", $JavaScript);
        undef(%Value);
        &vSendMenuBar(%Value);


        # Check that at least one document was selected
        if ( !defined($main::FormData{'Document'}) && !defined($main::FormData{'Documents'}) ) {
                print("<H3>Saving a Document Folder:</H3>\n");
                print("<H3><CENTER>Sorry, no document(s) were selected for saving.</CENTER></H3>\n");
                print("<P>\n");
                print("There needs to be a least one document selected in order to save it.\n");
                print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
                goto bailFromGetSaveFolder;
        }


        # Print up the title
        print("<H3> Kreiranje korisnièkog foldera: </H3>\n");

        # Print up the form
        printf("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetSaveFolder\" onSubmit=\"return checkForm(this)\" METHOD=POST>\n");

        # Print up the table start
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

        # Send the buttons
        print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=2> <INPUT TYPE=SUBMIT VALUE=\"Saèuvaj folder\"> <INPUT TYPE=RESET VALUE=\"Vrati poèetne vrijednosti\"> </TD></TR>\n");

        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
        
        # Send the fields
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Ime foldera: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"FolderName\" TYPE=TEXT SIZE=45> </TD></TR>\n");

        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis foldera: </TD> <TD ALIGN=LEFT VALIGN=TOP> <TEXTAREA INPUT NAME=\"FolderDescription\" COLS=45 ROWS=6 WRAP=VIRTUAL></TEXTAREA> </TD></TR>\n");

        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

        print("<TR><TD ALIGN=LEFT VALIGN=TOP>  Kliknite na ovaj kvadratiæ ako ¾elite postojeæi folder s istim imenom zamijeniti ovim novim: </TD> <TD ALIGN=LEFT VALIGN=TOP><INPUT TYPE=\"checkbox\" NAME=\"OverWrite\" VALUE=\"yes\"> </TD></TR>\n");
        
        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

        # List the documents
        if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {

                # Undefine the hash table in preparation
                undef(%Value);

                # Add document that were specifically selected
                if ( defined($main::FormData{'Document'}) ) {
                        foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                $Value{$Value} = $Value;
                        }
                }
                # Otherwise add documents that were selected by default
                elsif ( defined($main::FormData{'Documents'}) ) {
                        foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
                                $Value{$Value} = $Value;
                        }
                }
                        
                # Assemble the new content
                $main::FormData{'Document'} = join("\0", keys(%Value));
                
                # Delete the old content
                delete($main::FormData{'Documents'});

###FIX
                if ( defined($main::FormData{'Document'}) ) {
                        print("<TR>\n");
                        &bDisplayDocuments("Document", $main::FormData{'Document'}, "Document", undef, undef, 1);
                        print("</TR>\n");
                }
        }

        
        # List the hidden fields
        %Value = &hParseURLIntoHashTable(&sMakeDocumentURL(%main::FormData));
        foreach $Value ( keys(%Value) ) {
                foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
                        print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
                }
        }

        
        # Retain the 'from' folder name if it is defined as these documents are coming from it
        if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
                print("<INPUT TYPE=HIDDEN NAME=\"FromDocumentFolderObject\" VALUE=\"$main::FormData{'FromDocumentFolderObject'}\">\n");
        }

        
        # Retain the 'merge' folder name if it is defined as these documents are coming from them
        if ( defined($main::FormData{'MergeDocumentFolderObject'}) ) {
                foreach $Value ( split(/\0/, $main::FormData{'MergeDocumentFolderObject'}) ) {
                        print("<INPUT TYPE=HIDDEN NAME=\"MergeDocumentFolderObject\" VALUE=\"$Value\">\n");
                }
        }

        print("</TABLE>\n");
        print("</FORM>\n");
        

        # Bail from saving the document folder
        bailFromGetSaveFolder:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vSetSaveFolder()
#
#       Purpose:        This function saves that search and search name in a search file 
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vSetSaveFolder {

        my ($DocumentFolderFilePath, $HeaderName);
        my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
        my (@DocumentFolderList, $DocumentFolderEntry);
        my ($Document, %Document);
        my (%Value, @Values, $Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("Saving a Document Folder", undef);
        undef($Value);  
        &vSendMenuBar(%Value);


        # Check that at least one document was selected
        if ( !defined($main::FormData{'Document'}) && !defined($main::FormData{'Documents'}) ) {
                
                print("<H3>Saving a Document Folder:</H3>\n");
                print("<H3><CENTER>Sorry, no document(s) were selected for saving.</CENTER></H3>\n");
                print("<P>\n");
                print("There needs to be a least one document selected in order to save it.\n");
                print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
        
                goto bailFromSetSaveFolder;
        }


        # Check that the required fields are filled in
        if ( !(defined($main::FormData{'FolderName'}) || defined($main::FormData{'DocumentFolderObject'})) ) {
                
                # A required field is missing, so we suggest corrective action to the user.
                print("<H3> Spremanje foldera s dokumentima: </H3>\n");
                print("<H3><CENTER> Oprostite, nedostaju neke informacije. </CENTER></H3>\n");
                print("<P>\n");
                print("Polje <B>'folder name'</B> mora biti ispunjeno da bi se mogao kreirati folder s dokumentima.<P>\n");
                print("Kliknite na <B>'Back'</B> u svom browseru, ispunite polje koje nedostaje i poku¹ajtwe ponovo.\n");
                print("<P>\n");
        
                goto bailFromSetSaveFolder;
        }


        # Check that the folder is there if we are saving to an existing folder
        if ( defined($main::FormData{'DocumentFolderObject'}) ) {
                
                # Check the old document folder if it is defined
                if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {

                        # Set the document folder file path
                        $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'FromDocumentFolderObject'};
                
                        # Check to see if the old XML saved search file requested is there
                        if ( ! -f $DocumentFolderFilePath ) {
                                # Could not find the old saved search file
                                &vHandleError("Saving a Document Folder", "Sorry, we cant to access this document folder object because it is not there");
                                goto bailFromSetSaveFolder;
                        }

                        # Get information from the XML document folder file
                        $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
                
                        # Check that the entry is valid 
                        if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                                &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
                                goto bailFromSetSaveFolder;
                        }
                }


                # Set the document folder file path
                $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
        
                # Check to see if the XML saved search file requested is there
                if ( ! -f $DocumentFolderFilePath ) {
                        # Could not find the saved search file
                        &vHandleError("Saving a Document Folder", "Sorry, we cant to access this document folder object because it is not there");
                        goto bailFromSetSaveFolder;
                }

                # Get information from the XML document folder file
                $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
        
                # Check that the entry is valid 
                if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                        &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
                        goto bailFromSetSaveFolder;
                }
        }
        elsif ( defined($main::FormData{'FolderName'}) ) {

                # Get the document folder hash
                %Value = &hGetDocumentFolders;
                
                # Set the path/flag
                $DocumentFolderFilePath = $Value{$main::FormData{'FolderName'}};
                
                # Check that the document folder file does not already exist
                if ( defined($DocumentFolderFilePath) && !(defined($main::FormData{'OverWrite'}) && ($main::FormData{'OverWrite'} eq "yes")) ) {
        
                        # There is already a document folder with this name, so we suggest corrective action to the user.
                        print("<H3> Snimanje foldera s dokumentima: </H3>\n");
                        print("<H3><CENTER> Oprostite, veæ postoji folder s tim imenom. </CENTER></H3>\n");
                        print("<P>\n");
                        print("Kliknite na <B>'Back'</B> u svom browseru, promijenite <B>'ime foldera'</B> i poku¹ate ponovo. \n");
                        print("Alternativno, klikom na kvadratiæ, mo¾ete odabrati da ¾elite postojeæi folder zamijeniti ovim.\n");
                        print("<P>\n");
        
                        goto bailFromSetSaveFolder;
                }
        }


        # Save information in the folder
        if ( defined($main::FormData{'DocumentFolderObject'}) ) {
                
                # Get the data from the XML document folder file
                ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
        
                # Check that the entry is valid 
                if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                        &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
                        goto bailFromGetSavedSearch;
                }
        
                $FolderName =  $Value{'FolderName'};
                $FolderDescription =  $Value{'FolderDescription'};
                $FolderDocuments =  $Value{'FolderDocuments'};
                $CreationTime = $Value{'CreationTime'};
                $UpdateTime = time();

                
                # Merge the documents
                if ( defined($FolderDocuments) || defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
                        
                        # Undefine the hash table in preparation
                        undef(%Value);

                        # Make a hash table from the documents already in the document folder
                        if ( defined($FolderDocuments) ) {
                                foreach $Value ( split(/\0/, $FolderDocuments) ) {
                                        $Value{$Value} = $Value;
                                }
                        }
        
                        # Add document that were specifically selected
                        if ( defined($main::FormData{'Document'}) ) {
                                foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                        $Value{$Value} = $Value;
                                }
                        }
                        # Otherwise add documents that were selected by default
                        elsif ( defined($main::FormData{'Documents'}) ) {
                                foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
                                        $Value{$Value} = $Value;
                                }
                        }
        
                        # Assemble the new content
                        $FolderDocuments = join("\0", keys(%Value));
                        
                        # Delete the old content
                        delete($main::FormData{'Document'});
                        delete($main::FormData{'Documents'});
                }

        }
        elsif ( defined($main::FormData{'FolderName'}) ) {

                $FolderName = $main::FormData{'FolderName'};
                $FolderDescription = $main::FormData{'FolderDescription'};
        
                # Merge the documents
                if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) {
                        
                        # Undefine the hash table in preparation
                        undef(%Value);

                        # Add document that were specifically selected
                        if ( defined($main::FormData{'Document'}) ) {
                                foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                        $Value{$Value} = $Value;
                                }
                        }
                        # Otherwise add documents that were selected by default
                        elsif ( defined($main::FormData{'Documents'}) ) {
                                foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
                                        $Value{$Value} = $Value;
                                }
                        }
        
                        # Assemble the new content
                        $main::FormData{'Document'} = join("\0", keys(%Value));
                        
                        # Delete the old content
                        delete($main::FormData{'Documents'});
                }

                $FolderDocuments = $main::FormData{'Document'};
                $CreationTime = time();
                $UpdateTime = time();
        }


        # Save the document folder to a new file
        if ( &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) ) {

                # Are we pulling these documents from an existing folder?
                if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {

                        # Set the document folder file path
                        $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'FromDocumentFolderObject'};

                        # Get information from the XML document folder file
                        ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
                
                
                        $FolderName = $Value{'FolderName'};
                        $FolderDescription = $Value{'FolderDescription'};
                        $FolderDocuments = $Value{'FolderDocuments'};
                        $CreationTime = $Value{'CreationTime'};
                        $UpdateTime = time();
                
                
                        # Make a hash table from the documents selected for deletion, this serves as
                        # a lookup table when we loop through the existing documents
                        undef(%Value);
                        foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                $Value{$Value} = 1;
                        }
                        
                        # Parse out of the existing documents into a list
                        foreach $Value ( split(/\0/, $FolderDocuments) ) {
                                # Add the document if it is not on the deletion list
                                if ( !defined($Value{$Value}) ) {
                                        push @Values, $Value;
                                }
                        }
                        $FolderDocuments = join("\0", @Values);

                
                        # Save the document folder
                        &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
                
                }
                
                if ( defined($main::FormData{'MergeDocumentFolderObject'}) ) {
                        @Values = split(/\0/, $main::FormData{'MergeDocumentFolderObject'});
                        foreach $Value ( @Values ) {
                                # Set the document folder file path
                                if ( !(defined($main::FormData{'DocumentFolderObject'}) && ($main::FormData{'DocumentFolderObject'} eq $Value))) {
                                        $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $Value;
                                        unlink($DocumentFolderFilePath);
                                }
                        }
                }
        
                print("<H3> Èuvanje korisnièkog foldera: </H3>\n");
                print("<P>\n");
                print("<H3><CENTER> Va¹ folder je uspje¹no saèuvan! </CENTER></H3>\n");
                
                
        }
        else {

                # The document folder could not be saved, so we inform the user of the fact
                &vHandleError("Saving a Document Folder", "Sorry, we failed to save this document folder");
                goto bailFromSetSaveFolder;
        }


        # Bail from saving the document folder
        bailFromSetSaveFolder:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vListFolder()
#
#       Purpose:        This function allows the user list the document folders and
#                               sets up the links allowing the user to get a list of the documents
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::DocumentFolderFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vListFolder {

        my (@DocumentFolderList, %QualifiedDocumentFolders, $DocumentFolderEntry, $HeaderName);
        my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
        my (@Values, $Value, %Value);

        
        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make sure that we send the header
        &vSendHTMLHeader("Document Folders", undef);
        undef(%Value);
        $Value{'ListFolder'} = "ListFolder";
        &vSendMenuBar(%Value);
        undef(%Value);


        # Print out the document folders
        print("<H3> Korisnièki folderi: </H3>\n");
        

        # Get the document folder hash
        %QualifiedDocumentFolders = &hGetDocumentFolders;


        # Print up the document folders, if there is none, we put up a nice message
        if ( scalar(keys(%QualifiedDocumentFolders)) > 0 ) {
                                
                # Start the table
                print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
        
                # Start the form
                print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
                

                # Print the selector
                print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3>\n");
                print("<SELECT NAME=\"Action\">\n");
                print("<OPTION VALUE=\"DeleteFolder\">Obri¹i oznaèene foldere\n");
                print("<OPTION VALUE=\"GetMergeFolder\">Spoji oznaèene foldere u novi folder\n");
        
                for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
                        
                        $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
                
                        # Get the document folder file name and encode it
                        $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
                        $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
                        
                        print("<OPTION VALUE=\"SetMergeFolder&ToDocumentFolderObject=$DocumentFolderEntry\">Spoji oznaèene foldere u '$FolderName' folder\n");
                }
        
                print("</SELECT>\n");
                print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
                print("</TD></TR>\n");


                # List the folders
                for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
                
                        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");

                        $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};

                        # Get information from the XML document folder file
                        ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderEntry);

                        # Get the saved search file name and encode it
                        $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
                        $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
                        

                        $FolderName = $Value{'FolderName'};
                        $FolderDescription = $Value{'FolderDescription'};
                        $FolderDocuments = $Value{'FolderDocuments'};
                        $CreationTime = $Value{'CreationTime'};
                        $UpdateTime = $Value{'UpdateTime'};
                        

                        # Print the link
                        print("<TR><TD ALIGN=LEFT VALIGN=TOP WIDTH=1%><INPUT TYPE=\"checkbox\" NAME=\"DocumentFolderObject\" VALUE=\"$DocumentFolderEntry\"> </TD><TD ALIGN=LEFT VALIGN=TOP> Naziv: </TD> <TD ALIGN=LEFT VALIGN=TOP> $FolderName </TD></TR>\n");

                        # Print the folder description
                        $FolderDescription = defined($FolderDescription) ? $FolderDescription : "(Nije naveden)";
                        $FolderDescription =~ s/\n/<BR>/g;
                        $FolderDescription =~ s/\r/<BR>/g;
                        print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $FolderDescription </TD></TR>\n");
                        
                        if ( defined($FolderDocuments) ) {
                                @Values = split(/\0/, $FolderDocuments);
                                $Value = scalar( @Values );
                        }
                        else {
                                $Value = 0;
                        }
                        print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Broj rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
                        

                        $Value = &sGetPrintableDateFromTime($CreationTime);
                        print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
                        
                        $Value = &sGetPrintableDateFromTime($UpdateTime);
                        print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Datum zadnje promijene: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");

                        print("<TR><TD WIDTH=1%> </TD><TD ALIGN=LEFT VALIGN=TOP> </TD> <TD ALIGN=LEFT VALIGN=TOP> <A HREF=\"$ENV{'SCRIPT_NAME'}/GetFolder?DocumentFolderObject=$DocumentFolderEntry\" OnMouseOver=\"self.status='Display the documents in this document folder'; return true\">[ Otvori ovaj folder ] </A> </TD></TR>\n");
                }
                
                print("</FORM></TABLE>\n");
        }
        else {
                print("<H3><CENTER> Nema foldera! </CENTER></H3>\n");
        }
        
        
        # Bail from displaying document folders
        bailFromListFolder:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        $Value{'ListFolder'} = "ListFolder";
        &vSendMenuBar(%Value);
        undef(%Value);

        &vSendHTMLFooter;


        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vMergeFolder()
#
#       Purpose:        This function deletes a folder.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::DocumentFolderFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vMergeFolder {

        my ($Title, $HeaderName, $DocumentFolderFilePath, $DocumentFolderObject, $FolderDocuments);
        my ($Value, %Value);
        
        
        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Check to see if the document folder object is defined
        if ( ! defined($main::FormData{'DocumentFolderObject'}) ) {
                
                # Could not find the document folder file
                &vSendHTMLHeader("Merge Document Folders", undef);
                undef(%Value);
                &vSendMenuBar(%Value);
                print("<H3> Merge Document Folders: </H3>\n");
                print("<H3><CENTER> Sorry, no document folders were selected. </CENTER></H3>\n");
                print("<P>\n");
                print("You need to select at least one document folder in order to be able to perform an action on it.\n");
                print("<P>\n");
                return;
        }


        # Init the value hash
        undef(%Value);

        # Loop over document folder object
        $Value = $main::FormData{'DocumentFolderObject'} . 
                        ((defined($main::FormData{'ToDocumentFolderObject'})) ? "\0" . $main::FormData{'ToDocumentFolderObject'} : "");

        foreach $DocumentFolderObject ( split(/\0/, $Value) ) {

                # Set the document folder file path
                $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $DocumentFolderObject;
        
                # Check to see if the XML saved search file requested is there
                if ( ! -f $DocumentFolderFilePath ) {
                        next;
                }

                # Get information from the XML saved search file
                $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
        
                # Check that the entry is valid 
                if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                        next;
                }

                # Get the FolderDocuments symbol
                $FolderDocuments = &sGetTagValueFromXMLFile($DocumentFolderFilePath, "FolderDocuments");
                
                # Add each document to the hash
                foreach $Value ( split(/\0/,  $FolderDocuments) ) {
                        $Value{$Value} = $Value;
                }
        }

        # Set the document URL from the hash
        $main::FormData{'Document'} = join("\0", keys(%Value));


        if ( defined($main::FormData{'DocumentFolderObject'}) ) {
                $main::FormData{'MergeDocumentFolderObject'} = $main::FormData{'DocumentFolderObject'};
                delete($main::FormData{'DocumentFolderObject'});
        }

        if ( defined($main::FormData{'ToDocumentFolderObject'}) ) {
                $main::FormData{'DocumentFolderObject'} = $main::FormData{'ToDocumentFolderObject'};
                delete($main::FormData{'ToDocumentFolderObject'});
        }

        
        if ( $ENV{'PATH_INFO'} eq "/GetMergeFolder" ) {
                &vGetSaveFolder;
        }
        elsif  ( $ENV{'PATH_INFO'} eq "/SetMergeFolder" ) {
                &vSetSaveFolder;
        }
        

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vProcessFolder()
#
#       Purpose:        This function deletes a folder.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::DocumentFolderFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vProcessFolder {

        my ($Title, $HeaderName, $DocumentFolderFilePath, $DocumentFolderObject);
        my ($Value, %Value);
        
        
        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        if ( $ENV{'PATH_INFO'} eq "/DeleteFolder" ) {
                $Title = "Delete Document Folders";
        }
        
        
        # Make sure that we send the header
        &vSendHTMLHeader($Title, undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        
        print("<H3> $Title: </H3>\n");

        # Check to see if the document folder object is defined
        if ( ! defined($main::FormData{'DocumentFolderObject'}) ) {
                
                # Could not find the document folder file
                print("<H3><CENTER> Sorry, no document folders were selected. </CENTER></H3>\n");
                print("<P>\n");
                print("You need to select at least one document folder in order to be able to perform an action on it.\n");
                print("<P>\n");
                
                goto bailFromProcessFolder;
        }
        
        
        # Loop over document folder object
        foreach $DocumentFolderObject ( split(/\0/, $main::FormData{'DocumentFolderObject'}) ) {

                # Set the document folder file path
                $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $DocumentFolderObject;
        
                # Check to see if the XML saved search file requested is there
                if ( ! -f $DocumentFolderFilePath ) {
                        printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
                        next;
                }

                # Get information from the XML saved search file
                ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
        
                # Check that the entry is valid 
                if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                        printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
                }


                if ( unlink($DocumentFolderFilePath) ) {
                        printf("<P>Successfully deleted: %s\n", $Value{'FolderName'});
                }
                else {
                        printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
                }
        }

        print("<P>\n");

        # Bail from processing the document folder
        bailFromProcessFolder:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vGetFolder()
#
#       Purpose:        This function displays a document folder to the user.
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
#                                               $main::DocumentFolderFileNamePrefix, $main::RemoteUser
#
#       Returns:        void
#
sub vGetFolder {

        my ($HeaderName, $FolderName, $SelectorText, %ArticleFolder);
        my (@DocumentFolderList, $DocumentFolderEntry, %QualifiedDocumentFolders);
        my ($Value, %Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }


        # Make the document folder file name
        $DocumentFolderEntry = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};

        # Check to see if the XML document folder file requested is there
        if ( ! -f $DocumentFolderEntry ) {
                # Could not find the document folders file
                &vHandleError("Document Folder", "Sorry, we cant to access this document folder object because it is not there");
                goto bailFromGetFolder;
        }

        # Get information from the XML document folder file
        ($HeaderName, %ArticleFolder) = &shGetHashFromXMLFile($DocumentFolderEntry);

        # Check that the entry is valid 
        if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                &vHandleError("Document Folder", "Sorry, this document folder object is invalid");
                goto bailFromGetFolder;
        }


        # Make sure we send the header
        &vSendHTMLHeader("Document Folder", undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        
        print("<H3> Korisnièki folder: </H3>\n");

        
        # Start the form
        print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
        
        
        # Print the selector if there are any documents
        if ( defined($ArticleFolder{'FolderDocuments'}) ) {
                print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
                print("<TR><TD ALIGN=LEFT VALIGN=TOP>Odabranima se smatraju svi rezultati ukoliko niste uèinili nikakav dodatan odabir.</TD><TD ALIGN=RIGHT VALIGN=TOP> \n");
                print("<SELECT NAME=\"Action\">\n");
                print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
                if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
                        print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
                }
                if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
                        print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
                }
                print("<OPTION VALUE=\"DeleteDocument&DocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Obri¹i odabrane jedinice iz ovog foldera\n");
                print("<OPTION VALUE=\"GetSaveFolder&FromDocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Preseli odabrane jedinice u novi folder\n");
        
                
                # Get the document folder hash
                %QualifiedDocumentFolders = &hGetDocumentFolders;
        
                for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
                        
                        # Skip this folder
                        if ( $FolderName eq $ArticleFolder{'FolderName'} ) {
                                next;
                        }
                        
                        $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
                
                        # Get the document folder file name and encode it
                        $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
                        $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
                        
                        print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry&FromDocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Preseli odabrane jedinice u folder '$FolderName' \n");
                }
        
                print("</SELECT>\n");
                print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
                print("</TD></TR>\n");
                print("</TABLE>\n");
        }

        print("<CENTER><HR WIDTH=50%></CENTER>\n");


        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");

        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Naziv: </TD> <TD ALIGN=LEFT VALIGN=TOP> $ArticleFolder{'FolderName'} </TD></TR>\n");

        # Print the folder description
        $ArticleFolder{'FolderDescription'} = defined($ArticleFolder{'FolderDescription'}) ? $ArticleFolder{'FolderDescription'} : "(Nije naveden)";
        $ArticleFolder{'FolderDescription'} =~ s/\n/<BR>/g;
        $ArticleFolder{'FolderDescription'} =~ s/\r/<BR>/g;
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $ArticleFolder{'FolderDescription'} </TD></TR>\n");
        

        $Value = &sGetPrintableDateFromTime($ArticleFolder{'CreationTime'});
        print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
        
        $Value = &sGetPrintableDateFromTime($ArticleFolder{'UpdateTime'});
        print("<TR><TD ALIGN=LEFT VALIGN=TOP NOWRAP> Datum zadnje promijene: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
        
        print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");

        
        # Display a button to select all the documents if there are any
        if ( defined($ArticleFolder{'FolderDocuments'}) ) {

                $SelectorText = "";
                
                # Loop over each entry folder documents
                foreach $Value ( split(/\0/, $ArticleFolder{'FolderDocuments'}) ) {
                        $SelectorText .=  (($SelectorText ne "") ? "|" : "") . $Value;
                }
                
                $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
                print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> $SelectorText </TD></TR>\n");
        }

        if ( defined($ArticleFolder{'FolderDocuments'}) ) {
                print("<TR>\n");
                &bDisplayDocuments("Document", $ArticleFolder{'FolderDocuments'}, "Document", 1, undef, 1);
                print("</TR>\n");
        }
        else {
                print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2> This document folder does not contain any documents. </TD></TR>\n");
        }

        print("</FORM></TABLE>\n");
        
        # Bail from displaying the document folder
        bailFromGetFolder:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vProcessDocument()
#
#       Purpose:        This function deletes folder documents
#
#       Called by:      
#
#       Parameters:     void
#
#       Global Variables:       %main::ConfigurationData, %main::FormData,
#                                               $main::UserSettingsFilePath, $main::RemoteUser, 
#
#       Returns:        void
#
sub vProcessDocument {

        my ($Title, $DocumentFolderFilePath, $HeaderName);
        my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
        my (%Value, @Values, $Value);


        # Return an error if the remote user name/account directory is not defined
        if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
                &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
                &vSendHTMLFooter;
                return;
        }

        
        # Check to see if the XML document folder is there
        if ( !defined($main::FormData{'DocumentFolderObject'}) ) {
                # Could not find the document folders file
                &vHandleError($Title, "Sorry, the document folder object was not defined");
                goto bailFromProcessDocument;
        }


        # Set the title
        if ( $ENV{'PATH_INFO'} eq "/DeleteDocument" ) {
                $Title = "Delete Folder Documents";
        }


        # Make sure that we send the header
        &vSendHTMLHeader($Title, undef);
        undef(%Value);
        &vSendMenuBar(%Value);
        

        # Check to see if the document folder object is defined
        if ( ! (defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) ) {
                
                # No documents were defined
                print("<H3><CENTER> Sorry, no documents were selected. </CENTER></H3>\n");
                print("<P>\n");
                print("You need to select at least one document in order to be able to perform an action on it.\n");
                print("<P>\n");
                
                goto bailFromProcessDocument;
        }

        
        # Set the document folder file path
        $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};


        # Check to see if the XML document folder file requested is there
        if ( ! -f $DocumentFolderFilePath ) {
                # Could not find the document folders file
                &vHandleError($Title, "Sorry, we cant to access this document folder object because it is not there");
                goto bailFromProcessDocument;
        }


        # Get information from the XML document folder file
        ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);

        # Check that the entry is valid 
        if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
                &vHandleError($Title, "Sorry, this document folder object is invalid");
                goto bailFromProcessDocument;
        }


        $FolderName = $Value{'FolderName'};
        $FolderDescription = $Value{'FolderDescription'};
        $FolderDocuments = $Value{'FolderDocuments'};
        $CreationTime = $Value{'CreationTime'};
        $UpdateTime = time();


        # Make a hash table from the documents selected for deletion, this serves as
        # a lookup table when we loop through the existing documents
        # List the documents
        if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {

                # Undefine the hash table in preparation
                undef(%Value);

                # Add document that were specifically selected
                if ( defined($main::FormData{'Document'}) ) {
                        foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
                                $Value{$Value} = $Value;
                        }
                }
                # Otherwise add documents that were selected by default
                elsif ( defined($main::FormData{'Documents'}) ) {
                        foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
                                $Value{$Value} = $Value;
                        }
                }
        }


        # Parse out of the existing documents into a list
        foreach $Value ( split(/\0/, $FolderDocuments) ) {
                # Add the document if it is not on the deletion list
                if ( !defined($Value{$Value}) ) {
                        push @Values, $Value;
                }
        }
        $FolderDocuments = join("\0", @Values);


        # Save the document folder (now missing the selected documents)
        if ( &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) ) {

                print("<H3> $Title: </H3>\n");
                print("<P>\n");
                print("<H3><CENTER> The folder documents were successfully deleted. </CENTER></H3>\n");
                
        }
        else {

                # The documents coudl not be deleted, so we inform the user of the fact
                &vHandleError($Title, "Sorry, we failed to delete the selected folder documents");
                goto bailFromProcessDocument;
        }


        # Bail from deleting the documents
        bailFromProcessDocument:

        print("<CENTER><HR WIDTH=50%></CENTER>\n");
        undef(%Value);
        &vSendMenuBar(%Value);

        &vSendHTMLFooter;

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vRunSavedSearches()
#
#       Purpose:        Run the saved searches which are due
#
#       Called by:      
#
#       Parameters:     $PassedFrequency        search frequency        
#
#       Global Variables:       
#
#       Returns:        void
#
sub vRunSavedSearches {

        my ($PassedFrequency) = @_;
        my (@UserAccountsDirectoryList, $UserAccountsDirectory, @UserSavedSearchList, $UserSavedSearch);
        my (@SavedSearchFilePathList, @QualifiedSaveSearchFilePathList, $SavedSearchFilePath);
        my ($SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchString, $DeliveryFormat, $DeliveryMethod, $SearchFrequency, $SearchStatus, $CreationTime, $LastRunTime);
        my ($EmailAddress, $NewLastRunTime, $Databases, $HeaderName);
        my ($Status, $SearchResults, $FinalSearchString, $SearchResult, $ResultCount, $QueryReport, $ErrorNumber, $ErrorMessage);
        my ($ItemName, $MimeType, $HTML, $SavedFileHandle);
        my ($Value, %Value, $ValueEntry);


        # Check that we can actually run saved searches
        if ( !(defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes")) ) {
                print("Execution error - configuration setting: 'allow-regular-searches', setting not set or disabled.\n");
                return;
        }


        # Check that we have a user account directory
        if ( !defined($main::ConfigurationData{'user-accounts-directory'}) ) {
                print("Execution error - configuration setting: 'user-accounts-directory', setting not set.\n");
        }


        # Check that we have a script URL
        if ( !(defined($main::ConfigurationData{'script-url'}) && ($main::ConfigurationData{'script-url'} ne "yes")) ) {
                print("Execution error - configuration setting: 'script-url', setting not set.\n");
        }


        # Scoop up all the directories in the user accounts directory
        opendir(ACCOUNTS_DIRECTORY, $main::ConfigurationData{'user-accounts-directory'});
        @UserAccountsDirectoryList = grep(!/^\.\.?$/, readdir(ACCOUNTS_DIRECTORY));
        closedir(ACCOUNTS_DIRECTORY);
        
        # Loop over each user account
        foreach $UserAccountsDirectory ( @UserAccountsDirectoryList ) {
                
                # Read all the saved searches
                opendir(USER_ACCOUNT_DIRECTORY, $main::ConfigurationData{'user-accounts-directory'} . "/" . $UserAccountsDirectory);
                @UserSavedSearchList = grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY));
                closedir(USER_ACCOUNT_DIRECTORY);
                
                # And add each to the saved searches list
                foreach $UserSavedSearch ( @UserSavedSearchList ) {
                        push @SavedSearchFilePathList, $main::ConfigurationData{'user-accounts-directory'} . "/" . $UserAccountsDirectory . "/" . $UserSavedSearch;
                }
        }

        
        # Return here if there are no saved search to process
        if ( ! @SavedSearchFilePathList ) {
                print("Execution warning - no saved searches to process.\n");
                return;
        }
        

        # Loop over each file in the list, checking to see if it is time to
        # process this one, if so we add it to the qualified saved search list
        foreach $SavedSearchFilePath ( @SavedSearchFilePathList ) {

                # Get the header name from the saved search file
                $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchFilePath);

                # Skip this saved search file entry if it is not valid
                if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
                        print("Execution error - invalid saved search object: '$SavedSearchFilePath'.\n");
                        next;
                }

                
                # Get the delivery format from the saved search file
                $DeliveryFormat = &sGetTagValueFromXMLFile($SavedSearchFilePath, "DeliveryFormat");

                # Check the delivery format, it is undefined if the search is not a regular search
                if ( ! defined($DeliveryFormat) ) {
                        next;
                }
                
                # Check the validity of the delivery format 
                if ( ! defined($main::DeliveryFormats{$DeliveryFormat}) ) {
                        print("Execution error - invalid delivery method: '$DeliveryFormat' in saved search: '$SavedSearchFilePath'.\n");
                        next;
                }


                # Set the user settings file path name
                $main::UserSettingsFilePath = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/") + 1) . $main::UserSettingsFileName . $main::XMLFileNameExtension;

                # Check that this preference file is valid
                $HeaderName = &sGetObjectTagFromXMLFile($main::UserSettingsFilePath);
                
                # Skip this entry if it is not valid
                if ( !(defined($HeaderName) && ($HeaderName eq "UserSettings")) ) {
                        print("Execution error - invalid user settings object: '$main::UserSettingsFilePath'.\n");
                        next;
                }
                

                # Get the email address from the user settings file
                $EmailAddress = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");

                # Skip this entry if it is not valid
                if ( !defined($EmailAddress) ) {
                        print("Execution error - invalid email address in user settings object: '$main::UserSettingsFilePath'.\n");
                        next;
                }


                # Get the frequency requested for this saved search
                $SearchFrequency = &sGetTagValueFromXMLFile($SavedSearchFilePath, "SearchFrequency");
                
                # Check the search frequency, skip if it is undefined
                if ( !defined($SearchFrequency)) {
                        print("Execution error - undefined search frequency in user settings object: '$main::UserSettingsFilePath'.\n");
                        next;
                }

                # Check the search frequency, skip if it is invalid
                $Value = 0;
                foreach $ValueEntry ( @main::SearchFrequencies ) {
                        if ( $ValueEntry eq $SearchFrequency ) {
                                $Value = 1;
                                last;
                        }
                }
                if ( !$Value ) {
                        print("Execution error - invalid search frequency: '$SearchFrequency', in user settings object: '$main::UserSettingsFilePath'.\n");
                        next;
                }


                # Is this the frequency we are currently working on?
                if ( index($PassedFrequency, $SearchFrequency) < 0 ) {
                        next;
                }
                
                
                # It is, so we concatenate the saved search file name to the list of 
                # qualified saved search file names
                push @QualifiedSaveSearchFilePathList, $SavedSearchFilePath;
        }
                

        # Return here if there are no qualified saved search to process
        if ( ! @QualifiedSaveSearchFilePathList ) {
                return;
        }
        

        # Get the current time, this will be used as the new last run time
        $NewLastRunTime = time();


        # Loop each saved search in the qualified saved search list, processing each of them
        foreach $SavedSearchFilePath ( @QualifiedSaveSearchFilePathList ) {
                
                # Get information from the XML saved search file
                ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchFilePath);

                $SearchName = $Value{'SearchName'};
                $SearchDescription = $Value{'SearchDescription'};
                $SearchString = $Value{'SearchString'};
                $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
                $SearchFrequency = $Value{'SearchFrequency'};
                $SearchStatus = $Value{'SearchStatus'};
                $DeliveryFormat = $Value{'DeliveryFormat'};
                $DeliveryMethod = $Value{'DeliveryMethod'};
                $CreationTime = $Value{'CreationTime'};
                $LastRunTime = $Value{'LastRunTime'};


                # Check the search status, run the search if it is active
                if ( defined($SearchStatus) && ($SearchStatus eq "Active") ) {

                        # Get the last run time from the XML saved search file
                        if ( !defined($LastRunTime) ) {
                                $LastRunTime = "0";
                        }
        
                        
                        # Set the remote user name
                        $main::RemoteUser = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/"));
                        $main::RemoteUser = substr($main::RemoteUser, rindex($main::RemoteUser,"/") + 1);
        
                        # Set the user directory path
                        $main::UserAccountDirectoryPath = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/") + 1);                
        
                        # Set the user settings file path name
                        $main::UserSettingsFilePath = $main::UserAccountDirectoryPath . $main::UserSettingsFileName . $main::XMLFileNameExtension;              

                        # Get the email address from the user settings file
                        $EmailAddress = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
        
                        # Parse the URL search string into the form data global
                        %main::FormData = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
        
                
                        ##########################
                        # Uncomment this to force a check over the complete database rather than
                        # just getting the documents which changed since the last run
                        # $LastRunTime = 0;
                        ##########################
        
                        
                        # Clear the date restriction fields, they are meaningless in this context
                        delete($main::FormData{'Since'});
                        delete($main::FormData{'Before'});
        
                        # Set the last run time restriction
                        $main::FormData{'LastRunTime'} = $LastRunTime;
        
                
                        # Generate the search string
                        $FinalSearchString = &sMakeSearchString(%main::FormData);
        
        
                        # Set the local database names 
                        if ( defined($main::FormData{'Database'}) ) {
                                
                                # Set the database variable and convert all the '\0' to ','
                                $Databases = $main::FormData{'Database'};
                                $Databases =~ tr/\0/,/;
                        }
        
                        
                        print("Execution - saved search: '$SavedSearchFilePath', database: '$Databases', search: '$FinalSearchString', time: '$LastRunTime'.\n");
                        
                        # Run the search
                        ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Databases, $FinalSearchString, "", 0, $main::DefaultMaxDoc - 1, $main::ConfigurationData{'max-score'});

                        if ( ! $Status ) {
                                ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
                                print("Execution error - failed to run the search.\n");
                                print("The following error message was reported: <BR>\n");
                                print("Error Message: $ErrorMessage <BR>\n");
                                print("Error Number: $ErrorNumber <BR>\n");
                                next;
                        }
                        
                        
                        # Get the number of results we got from the search
                        $ResultCount = 0;
                        foreach $SearchResult ( split(/\n/, $SearchResults) ) {
        
                                # Parse the headline, also get the first document item/type
                                (undef, undef, undef, undef, undef undef, $ItemName, $MimeType, undef) = split(/\t/, $SearchResult, 9);
                
                                # Is this a query report
                                if ( !(($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType)) ) {
                                        # Increment the result count
                                        $ResultCount++;
                                }
                        }


                        # Do we want to deliver email messages with no new results?
                        if ( defined($main::ConfigurationData{'deliver-empty-results-from-regular-search'}) && ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} eq "no") ) {
                                if ( $ResultCount == 0 ) {
                                        next;
                                }
                        }
        
        
                        # Open the mail application, put put an error message if we cant open it and loop to the next saved search
                        if ( ! open(RESULT_FILE, "| $main::ConfigurationData{'mailer-application'} $EmailAddress ") ) {
                                print("Execution error - failed to launch mail application: '$main::ConfigurationData{'mailer-application'}', system error: $!.\n");
                                next;
                        }
                                
                                
                        # Save the file handle for stdout and select the result file handle as the default handle
                        $SavedFileHandle = select;
                        select RESULT_FILE;
                        

                        # Print out the message header (To:)
                        print ("To: $EmailAddress\n");
                
                        # Print out the message header (From:)
                        if ( defined($main::ConfigurationData{'site-admin-email'}) && ($main::ConfigurationData{'site-admin-email'} ne "") ) {
                                print ("From: $main::ConfigurationData{'site-admin-email'}\n");
                        }
                
                        # Print out the message header (Subject:)
                        print ("Subject: Results for saved search: $SearchName\n");
                        

                        # Print out the message header (Content-Type)
                        if ( $DeliveryMethod eq "attachement" ) {
                                print("Mime-Version: 1.0\n");
                                print("Content-Type: multipart/mixed; boundary=\"============_-1234567890==_============\"\n");
                        }
                        else {
                                print("Mime-Version: 1.0\n");
                                printf("Content-Type: %s\n\n", ($DeliveryFormat eq "text/html") ? "text/html" : "text/plain");
                        }
                        
                        # Print out the separating new line between message header and message body
                        print("\n");
        
        
                        # Print out mime part separator and mime header for the message header
                        if ( $DeliveryMethod eq "attachement" ) {
                                print("--============_-1234567890==_============\n");
                                printf("Content-Type: text/plain; charset=\"us-ascii\"\n\n\n");
                                
                                if ( $DeliveryFormat eq "text/plain" ) {
                                        print("The search results are attached to this email message as a plain text\n");
                                        print("file. This file can be opened with a any word processor or text editor.\n");
                                }
                                elsif ( $DeliveryFormat eq "text/html" ) {
                                        print("The search results are attached to this email message as an HTML\n");
                                        print("file. This file can be opened with Netscape or Internet Explorer.\n");
                                }
                                
                                print("--============_-1234567890==_============\n");
                                $Value = "citations." . (($DeliveryFormat eq "text/html") ? "html" : "txt");
                                print("Content-Type: $DeliveryFormat; name=\"$Value\"\n");
                                print("Content-Disposition: attachment; filename=\"$Value\"\n\n");
                        }


                        # Get the current date
                        $Value = &sGetPrintableDateFromTime();

                        # Set the HTML flag
                        $HTML =  ( $DeliveryFormat eq "text/html" ) ? 1 : 0;
                        
                        # Write out the search result header
                        ($Status, $QueryReport) = &bsDisplaySearchResults("Search Results for: $SearchName:", $SearchDescription, $Value, $SearchFrequency, $SearchResults, undef, $main::ConfigurationData{'script-url'}, 1, 1, $HTML, %main::FormData);
        
                        
                        # Print out mime part separator and mime header for the message footer
                        if ( $DeliveryMethod eq "attachement" ) {
                                print("--============_-1234567890==_============\n");
                                printf("Content-Type: %s; charset=\"us-ascii\"\n\n\n", ($DeliveryFormat eq "text/html") ? "text/html" : "text/plain");
                        }
                        
                        
                        # Print out the profile result footer
                        if ( $DeliveryFormat eq "text/html" ) {
                                print("<BR><HR>\n");
                                print("Saved search by the <A HREF=\"$main::ConfigurationData{'script-url'}\">MPS Information Server </A><BR>\n"); 
                                print("Created by <A HREF=\"http://www.fsconsult.com/\">FS Consulting, Inc.</A><BR>\n"); 
                                print("<HR><BR>\n");
                                print("</BODY>\n");
                        }
                        elsif ( ($DeliveryFormat eq "text/plain") || ($DeliveryFormat eq "text/medline-citation") ) {
                                print("----------------------------------------------------------------------\n");
                                print("Saved search by the MPS Information Server [URL: $main::ConfigurationData{'script-url'}].\n"); 
                                print("Created by FS Consulting, Inc. [URL: http://www.fsconsult.com/].\n"); 
                                print("----------------------------------------------------------------------\n");
                                
                        }
                
                        # Print out mime part separator for the end of the message
                        if ( $DeliveryMethod eq "attachement" ) {
                                print("--============_-1234567890==_============--\n");
                        }
                
        
                        # Restore the saved file handle
                        select $SavedFileHandle;
                        
                        # Close the result file
                        close(RESULT_FILE);
                        
                }
                else {
                        print("Execution - saved search: '$SavedSearchFilePath' is currently inactive.\n");
                }

                # Save the search object
                if ( ! &iSaveSearch($SavedSearchFilePath, $SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $NewLastRunTime) ) {
                        print("Execution error - failed to save search object: '$SavedSearchFilePath'.\n");
                }

        }               # foreach ()

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       vLog()
#
#       Purpose:        This a logging function which logs any passed printf()
#                               formatted string to STDOUT and the log file if it is defined.
#
#                               If the log file cannot be opened for appending, nothing will
#                               be written to it.
#
#       Called by:      
#
#       Parameters:     @_
#                               
#       Global Variables:       $main::LogFilePath
#
#       Returns:        void
#
sub vLog {

        # Log to defined log file
        if ( defined($main::LogFilePath) && ($main::LogFilePath ne "") && open(LOG_FILE, ">>$main::LogFilePath") ) {
                print(LOG_FILE @_);
                close(LOG_FILE);
        }

        return;

}


#--------------------------------------------------------------------------
#
#       Function:       main()
#
#       Purpose:        main
#
#       Called by:      
#
#       Parameters:     
#
#       Global Variables:       
#
#       Returns:        void
#

        my ($Status);
        my (%Value, $Value);


        # Roll over the log file (ignore the status)
#       &iRolloverLog($main::LogFilePath, $main::LogFileRollOver);


        # Verify that we are running the correct perl version, assume upward compatibility
        if ( $] < 5.004 ) {
                &vLog("Error - this script needs to be run with Perl version 5.004 or better.\n");
                &vSendHTMLFooter;
                exit (-1);
        }


        # Load up the configuration file
        ($Status, %main::ConfigurationData) = &bhReadConfigurationFile($main::ConfigurationFilePath);
        if ( ! $Status ) {
                &vSendHTMLFooter;
                exit (-1);
        }
        
        
        # Set any defaults in the configuration
        if ( ! &bSetConfigurationDefaults(\%main::ConfigurationData, \%main::DefaultSettings) ) {
                &vSendHTMLFooter;
                exit (-1);
        }
        
        
        # Check for a minimal configuration
        if ( ! &bCheckMinimalConfiguration(\%main::ConfigurationData, \@main::RequiredSettings) ) {
                &vSendHTMLFooter;
                exit (-1);
        }
                
        
        # Check that the configuration paths specified is correct and can be accessed
        if ( ! &bCheckConfiguration ) {
                &vSendHTMLFooter;
                exit (-1);
        }
        

        # Get the database descriptions
        if ( ! &bGetDatabaseDescriptions ) {
                &vSendHTMLFooter;
                exit (-1);
        }
        
        
        # Set up the server
        if ( ! &bInitializeServer ) {
                &vSendHTMLFooter;
                exit (-1);
        }

        # fill filed descriptions
        &fill_SearchFieldDescriptions_fromDB('ps');

        # Are we running as a CGI-BIN script
        if ( $ENV{'GATEWAY_INTERFACE'} ) {
        

                # Check the CGI environment
                if ( ! &bCheckCGIEnvironment ) {
                        &vSendHTMLFooter;
                        exit (-1);
                }
                
        
                # Set and verify the environment (dont comment this out).
                if ( ! &bSetupCGIEnvironment ) {
                        &vSendHTMLFooter;
                        exit (-1);
                }
                

                if ( defined($main::FormData{'GetSearch'}) ) {
                        $ENV{'PATH_INFO'} = "/GetSearch";
                        delete($main::FormData{'GetSearch'});
                        delete($main::FormData{'GetSearch'});
                }
                
                if ( defined($main::FormData{'ListSearchHistory'}) ) {
                        $ENV{'PATH_INFO'} = "/ListSearchHistory";
                        delete($main::FormData{'ListSearchHistory'});
                        delete($main::FormData{'ListSearchHistory'});
                }
                
                if ( defined($main::FormData{'ListSavedSearch'}) ) {
                        $ENV{'PATH_INFO'} = "/ListSavedSearch";
                        delete($main::FormData{'ListSavedSearch'});
                        delete($main::FormData{'ListSavedSearch'});
                }
                
                if ( defined($main::FormData{'ListFolder'}) ) {
                        $ENV{'PATH_INFO'} = "/ListFolder";
                        delete($main::FormData{'ListFolder'});
                        delete($main::FormData{'ListFolder'});
                }
                
                if ( defined($main::FormData{'GetUserSettings'}) ) {
                        $ENV{'PATH_INFO'} = "/GetUserSettings";
                        delete($main::FormData{'GetUserSettings'});
                        delete($main::FormData{'GetUserSettings'});
                }
                

# foreach $Value ( keys (%main::FormData) ) {
#       $Status = defined($main::FormData{$Value}) ? $main::FormData{$Value} : "(undefined)";
#       &vLog("[\$main::FormData{'$Value'} = '$Status']\n");
# }
                
                # Check for 'Action', set the PATH_INFO from it if it is set
                if ( defined($main::FormData{'Action'}) ) {

                        if ( ($Value = index($main::FormData{'Action'}, "&")) > 0 ) {
                                 %Value = &hParseURLIntoHashTable(&lDecodeURLData(substr($main::FormData{'Action'}, $Value)));
                                 $main::FormData{'Action'} = substr($main::FormData{'Action'}, 0, $Value);
                                 foreach $Value ( keys(%Value) ) {
                                        $main::FormData{$Value} = $Value{$Value};
                                 }
                        }
                
                        $ENV{'PATH_INFO'} = "/" . $main::FormData{'Action'};
                        delete($main::FormData{'Action'});
                }
                
                
                # Default to search if PATH_INFO is not defined
                if ( !defined($ENV{'PATH_INFO'}) || ($ENV{'PATH_INFO'} eq "") ) {
                        $ENV{'PATH_INFO'} = "/GetSearch";
                }
                
                        
                # Check what was requested and take action appropriately
                if ( ($ENV{'PATH_INFO'} eq "/GetSearch") || ($ENV{'PATH_INFO'} eq "/GetSimpleSearch") || ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ) {
                        &vGetSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetSearchResults" ) {
                        &vGetSearchResults;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetDatabaseInfo" ) {
                        &vGetDatabaseInfo;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetDocument" ) {
                        &vGetDocument;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
                        &vGetDocument;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetUserSettings" ) {
                        &vGetUserSettings;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/SetUserSettings" ) {
                        &vSetUserSettings;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/ListSearchHistory" ) {
                        &vListSearchHistory;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetSearchHistory" ) {
                        &vGetSearchHistory;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetSaveSearch" ) {
                        &vGetSaveSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/SetSaveSearch" ) {
                        &vSetSaveSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/ListSavedSearch" ) {
                        &vListSavedSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetSavedSearch" ) {
                        &vGetSavedSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
                        &vProcessSavedSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
                        &vProcessSavedSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
                        &vProcessSavedSearch;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetSaveFolder" ) {
                        &vGetSaveFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/SetSaveFolder" ) {
                        &vSetSaveFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/ListFolder" ) {
                        &vListFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/SetMergeFolder" ) {
                        &vMergeFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetMergeFolder" ) {
                        &vMergeFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/DeleteFolder" ) {
                        &vProcessFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/GetFolder" ) {
                        &vGetFolder;
                }
                elsif ( $ENV{'PATH_INFO'} eq "/DeleteDocument" ) {
                        &vProcessDocument;
                }
                else {
                        $ENV{'PATH_INFO'} = "/GetSearch";
                        &vGetSearch;
                }
        
        }
        else {

                my ($RunSearches, $Param, $Frequency, $Mday, $Wday);


                # We are running as a stand alone script
                
        
                #
                # Initialize the variables
                #
        
                # Run Searches?
                #       0 - dont run searches
                #       1 - run searches
                $RunSearches = 1;
        
        
                # Init the frequency
                $Frequency = "";

                # Check for command parameters
                foreach $Param ( @ARGV ) {
                
                        if ( $Param =~ /^-nos/i ) {
                                # Dont run searches
                                $RunSearches = 0;
                        }
                        elsif ( $Param =~ /^-s/i ) {
                                # Run searches
                                $RunSearches = 1;
                        }
                        elsif ( $Param =~ /^-d/i ) {
                                # Want to run the daily
                                $Frequency .= "|Daily|";
                        }
                        elsif ( $Param =~ /^-w/i ) {
                                # Want to run the weekly
                                $Frequency .= "|Weekly|";
                        }
                        elsif ( $Param =~ /^-m/i ) {
                                # Want to run the monthly
                                $Frequency .= "|Monthly|";
                        }
                        elsif ( $Param =~ /^-h/i ) {
                                # help
                                print("Usage: Search.cgi [-nosearch|-search] [-daily][-weekly][-monthly][-help]\n");
                                print("\n");
                                print("                  [-nosearch|-search]  whether to run or not run searches (default = -search).\n");
                                print("                  [-daily] run daily crawls/searches (overrides default).\n");
                                print("                  [-weekly] run weekly crawls/searches (overrides default).\n");
                                print("                  [-monthly] run monthly crawls/searches (overrides default).\n");
                                print("                  [-help] print the usage and exit.\n");
                                exit (0);
                        }
                        else {
                                # Invalid param
                                print("\tError - invalid parameter: '$Param', run 'Search.cgi -help' to get parameter information.\n");
                                exit (-2);
                        }
                }

        
                # Did we set a frequency usign a command line parameter?
                if ( $Frequency eq "" ) {
                        
                        # We did not, so we set it based on the following rules
                        #
                        #       monday-sunday           run the daily
                        #       sunday                          run the weekly
                        #       1st of the month        run the monthly
                        #       

                        # Create an ANSI format date/time field 
                        (undef, undef, undef, $Mday, undef, undef, $Wday, undef, undef)  = localtime();
                
                        # Always do the daily
                        $Frequency = "|Daily|";
                        
                        # Check for sunday, append the weekly
                        if ( $Wday == 0 ) {
                                $Frequency .= "|Weekly|";
                        }
                
                        # Check for the 1st of the month, append the monthly
                        if ( $Mday == 1 ) {
                                $Frequency .= "|Monthly|";
                        }
                }
                
                
                # Log stuff
                print("Execution - Frequency: $Frequency\n");


                # Run the searches
                if ( $RunSearches == 1 ) {
                        &vRunSavedSearches($Frequency);
                }
        }


        # Shutdown the server
        &bShutdownServer;


        exit (0);


#--------------------------------------------------------------------------

# fill SearchFieldDescriptions from one database

# 2002-06-08 Dobrica Pavlinusic <dpavlin@rot13.org>

sub fill_SearchFieldDescriptions_fromDB {

        my ($Database) = @_;

        # Get the database field information
        my ($Status, $Text) = MPS::GetDatabaseFieldInfo($main::MPSSession, $Database);

        if ( $Status ) {
                foreach my $FieldInformation ( split(/\n/, $Text) ) {
                        my ($FieldName, $FieldDescription, undef) = split(/\t/, $FieldInformation, 3);
                        $main::SearchFieldDescriptions{$FieldName} = $FieldDescription;
                }
        } else {
                &vLog("Error - cant read database description from '$Database'\n");
        }
}

#--------------------------------------------------------------------------
# show list of all databases
#
# usage: ShowDatabaseCheckBoxes(@SelectedDatabases)

sub ShowDatabaseCheckBoxes {
        # Parse out the database names and put them into a
        # hash table, they should be separated with a '\0'
        my %Value;

        foreach my $ItemEntry ( @_ ) {
                $Value{$ItemEntry} = $ItemEntry;
        }
                
        print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0>\n");
        print "<tr><td colspan=3 align=\"center\">
                <font size=-1>Oznaèi
                        <a href=\"javascript:SetChecked(1)\">sve</a>,
                        <a href=\"javascript:SetChecked(0)\">niti jednu</a>.
                </font>
                </td></tr>";

        my @html_database;

        foreach my $key ( sort keys %main::DatabaseSort ) {
                my $DatabaseName = $main::DatabaseSort{$key};
                my $Value = ((defined($Value{$DatabaseName})) || (scalar(keys(%main::DatabaseDescriptions)) == 1) || !defined($main::RemoteUser) ) ? "CHECKED" : "";
                my $ItemEntry = &lEncodeURLData($DatabaseName);
                if ($main::DatabaseDescriptions{$DatabaseName}) {
                        push @html_database,"<TD ALIGN=LEFT VALIGN=TOP><INPUT TYPE=\"checkbox\" NAME=\"Database\" VALUE=\"$DatabaseName\" $Value> <A HREF=\"$ENV{'SCRIPT_NAME'}/GetDatabaseInfo?Database=$ItemEntry\" OnMouseOver=\"self.status='Informacije io bazi $main::DatabaseDescriptions{$DatabaseName} '; return true\"> $main::DatabaseDescriptions{$DatabaseName}  </A> </TD>\n";
                } else {
                        push @html_database,"<td align=left valign=top>$main::DatabaseDescriptions{$DatabaseName}</td>\n";
                }
        }


        if ($main::ConfigurationData{'output-colums'}) {
                # create database names in columns

                my $cols = $main::ConfigurationData{'show-nr-colums'};
                my $next = int($#html_database/$cols) ;

                for(my $i=0; $i <= $next ; $i++) {
                        print("<tr>");
                        for(my $j=0; $j <= $cols; $j++) {
                                print($html_database[$i+$next*$j+$j] || '');
                        }
                        print("</tr>");
                }

        } else {
                for(my $i=0; $i <= $#html_database ; $i=$i+1) {
                        print("<tr>",$html_database[$i],"</tr>");
                }
        }

        print("</TABLE>\n");
}