/[local]/search/Search.cgi
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Annotation of /search/Search.cgi

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.17 - (hide annotations)
Tue Jun 25 16:47:58 2002 UTC (21 years, 9 months ago) by dpavlin
Branch: MAIN
Changes since 1.16: +7 -5 lines
polja se ne razlijecu

1 dpavlin 1.1 #!/usr/bin/perl -w
2    
3     #*****************************************************************************
4 dpavlin 1.9 # Copyright (C) 1993-2000, FS Consulting Inc. All rights reserved *
5     # *
6     # *
7     # This notice is intended as a precaution against inadvertent publication *
8     # and does not constitute an admission or acknowledgement that publication *
9     # has occurred or constitute a waiver of confidentiality. *
10     # *
11     # This software is the proprietary and confidential property *
12     # of FS Consulting, Inc. *
13 dpavlin 1.1 #*****************************************************************************
14    
15 dpavlin 1.4 #print "Content-type: text/plain\n\n";
16    
17 dpavlin 1.10 #use Data::Dumper;
18 dpavlin 1.9
19 dpavlin 1.1 #--------------------------------------------------------------------------
20     #
21     # Author: Francois Schiettecatte (FS Consulting, Inc.)
22     # Creation Date: 8/9/96
23    
24    
25     #--------------------------------------------------------------------------
26     #
27     # Description:
28     #
29     # This script implements the search interface into the search engine. We
30     # interface with the search engine using the Direct protocol.
31     #
32    
33    
34     #--------------------------------------------------------------------------
35     #
36     # Modification Log
37     #
38     # Date:
39     # Author:
40     # Organization:
41     # Email:
42     # Description:
43     #
44     #
45     # Date: 8/9/96
46     # Author: Francois Schiettecatte
47     # Organization: FS Consulting, Inc.
48     # Email: francois@fsconsult.com
49     # Description: First cut.
50    
51    
52     #--------------------------------------------------------------------------
53     #
54     # CGI-BIN mode usage
55     #
56    
57     # We use the following environment variables from the cgi-bin environment:
58     #
59     # $PATH_INFO - action requested
60     # $QUERY_STRING - contains the query
61     # $REMOTE_USER - user account name
62     # $REQUEST_METHOD - request method
63     # $SCRIPT_NAME - script name
64     #
65    
66    
67     # We create the following variables as we go along,
68     # these will both be empty if this is a guest user
69     #
70     # $main::RemoteUser - contains the remote user name
71     # $main::UserAccountDirectoryPath - contains the path name to the user account directory
72     # $main::UserSettingsFilePath - contains the path name to the user information file
73     #
74    
75    
76     # User directory structure
77     #
78     # /AccountName (user directory)
79     #
80    
81    
82     #--------------------------------------------------------------------------
83     #
84     # Pragmatic modules
85     #
86    
87     use strict;
88    
89    
90     #--------------------------------------------------------------------------
91     #
92     # Set the default configuration directories, files & parameters
93     #
94    
95    
96     # Root directory path
97     $main::RootDirectoryPath = (($main::Index = rindex($0, "/")) >= 0) ? substr($0, 0, $main::Index) : ".";
98    
99     # Program name
100     $main::ProgramName = (($main::Index = rindex($0, "/")) >= 0) ? substr($0, $main::Index + 1) : $0;
101    
102     # Program base name
103     $main::ProgramBaseName = (($main::Index = rindex($main::ProgramName, ".")) >= 0) ? substr($main::ProgramName, 0, $main::Index) : $main::ProgramName;
104    
105    
106     # Log directory path
107     $main::LogDirectoryPath = $main::RootDirectoryPath . "/logs";
108    
109    
110     # Configuration file path
111     $main::ConfigurationFilePath = $main::RootDirectoryPath . "/" . $main::ProgramBaseName . ".cf";
112    
113     # Log file path
114     $main::LogFilePath = $main::LogDirectoryPath . "/" . lc($main::ProgramBaseName) . ".log";
115    
116    
117    
118     # Log file roll-over
119     #$main::LogFileRollOver = 0;
120    
121    
122    
123     #--------------------------------------------------------------------------
124     #
125     # Required packages
126     #
127    
128     # Load the libraries
129     push @INC, $main::RootDirectoryPath;
130     require "Library.pl";
131    
132    
133     # Load the MPS Information Server library
134     use MPS;
135    
136     #--------------------------------------------------------------------------
137     #
138     # Environment variables
139     #
140    
141     # Set up the environment so that we can find the external applications we need
142     $ENV{'PATH'} = "/bin:/usr/bin:/sbin:/usr/sbin:/usr/ucb:/usr/etc";
143     $ENV{'LD_LIBRARY_PATH'} = "/usr/lib";
144    
145    
146     #--------------------------------------------------------------------------
147     #
148     # Global
149     #
150    
151     # Configuration global (used to store the information read in from the configuration file)
152     undef(%main::ConfigurationData);
153    
154    
155     # Database descriptions global (used to store the information read in from the database description file)
156     undef(%main::DatabaseDescriptions);
157     undef(%main::DatabaseSort);
158    
159    
160     # Database Filters global (used to store the information read in from the database description file)
161     undef(%main::DatabaseFilters);
162    
163    
164     # Global flags which are set after sending the html header and footer
165     $main::HeaderSent = 0;
166     $main::FooterSent = 0;
167    
168     # Form data global (this is used to store the information decoded from a form)
169     undef(%main::FormData);
170    
171    
172     # User account information
173     undef($main::UserSettingsFilePath);
174     undef($main::UserAccountDirectoryPath);
175     undef($main::RemoteUser);
176    
177    
178     $main::MPSSession = 0;
179    
180     #--------------------------------------------------------------------------
181     #
182     # Configuration Constants
183     #
184    
185    
186 dpavlin 1.3 # read configuration fields
187 dpavlin 1.4 require "config.pm";
188 dpavlin 1.1
189     # List of required configuration settings
190     @main::RequiredSettings = (
191     'html-directory',
192     'logs-directory',
193     'image-base-path',
194     'database-directory',
195     'configuration-directory'
196     );
197    
198    
199    
200     $main::DatabaseName = "database-name";
201     $main::DatabaseFiltersPackage = "database-filters-package";
202     $main::DatabaseDocumentFilter = "database-document-filter";
203     $main::DatabaseSummaryFilter = "database-summary-filter";
204     $main::DatabaseRelevanceFeedbackFilter = "database-relevance-feedback-filter";
205    
206    
207     #--------------------------------------------------------------------------
208     #
209     # Application Constants
210     #
211    
212    
213     # XML file name extension
214     $main::XMLFileNameExtension = ".xml";
215    
216    
217     # User Settings file
218     $main::UserSettingsFileName = "UserSettings";
219    
220     # Saved Search file preamble
221     $main::SavedSearchFileNamePrefix = "SavedSearch";
222    
223     # Search history file preamble
224     $main::SearchHistoryFileNamePrefix = "SearchHistory";
225    
226     # Document Folder file preamble
227     $main::DocumentFolderFileNamePrefix = "DocumentFolder";
228    
229    
230     # Query report item name and mime type
231     $main::QueryReportItemName = "document";
232     $main::QueryReportMimeType = "application/x-wais-report";
233    
234    
235     # Array of mime type names, we use this to map
236     # mime types to mime type names (which are more readable)
237     %main::MimeTypeNames = (
238     'text/plain', 'Text',
239     'text/html', 'HTML',
240     'text/http', 'HTML',
241     'text/http', 'HTML',
242     'image/gif', 'GIF Image',
243     'image/tif', 'TIF Image',
244     'image/jpeg', 'JPEG Image',
245     'image/jfif', 'JPEG Image',
246     );
247    
248    
249     # Array of mime types that we can resonably use for relevance feedback
250     %main::RFMimeTypes = (
251     'text/plain', 'text/plain',
252     'text/html', 'text/html',
253     'text/http', 'text/http',
254     );
255    
256    
257     # Array of mime types that are in HTML
258     %main::HtmlMimeTypes = (
259     'text/html', 'text/html',
260     'text/http', 'text/http',
261     );
262    
263    
264     # DbP: replaced by NormalSearchFieldNames and AdvancedSearchFieldNames
265     # Search fields
266     #@main::SearchFieldNames = (
267     # '200-ae',
268     # '700,701,702,710,711',
269     # '610'
270     #);
271    
272     # DbP: this variable will be filled using MPS::GetDatabaseFieldInfo
273     %main::SearchFieldDescriptions = (
274     # 'title', 'Title',
275     # 'abstract', 'Abstract',
276     # 'author', 'Author',
277     # 'journal', 'Journal',
278     );
279    
280    
281     # Date list
282     @main::PastDate = (
283     'Week',
284     'Month',
285     '3 Months',
286     '6 Months',
287     '9 Months',
288     'Year'
289     );
290    
291     # Default maximum number of documents
292     $main::DefaultMaxDoc = 50;
293    
294     # Maximum docs list used for the search form pull-down
295     @main::MaxDocs = ( '10', '25', '50', '100', '250', '500', '750');
296    
297    
298     # Default maximum search history
299     $main::DefaultMaxSearchHistory = 15;
300    
301    
302     # Summary type for the settings form pull-down
303     %main::SummaryTypes = (
304     'none', 'None',
305     'keyword', 'Keywords in Context',
306     'default', 'Default summary',
307     );
308    
309    
310     # Summary length for the settings form pull-down
311     @main::SummaryLengths = ( '20', '40', '60', '80', '100', '120' );
312    
313     # Default summary length
314     $main::DefaultSummaryLength = 40;
315    
316     # Default summary type
317     $main::DefaultSummaryType = "default";
318    
319    
320     # Similar documents for the settings form pull-down
321     @main::SimilarDocuments = ( '1', '3', '5', '10' );
322    
323     # Default similar document
324     $main::DefaultSimilarDocument = 5;
325    
326     # Token span on either side of the summary keyword
327     $main::SummaryKeywordSpan = 9;
328    
329    
330     # Delivery format
331     %main::DeliveryFormats = (
332     'text/plain', 'Plain text',
333     'text/html', 'HTML',
334     );
335    
336     # Delivery methods
337     %main::DeliveryMethods = (
338     'message', 'Email message',
339     'attachement', 'Email attachement',
340     );
341    
342    
343     # Search frequency
344     @main::SearchFrequencies = (
345     'Daily',
346     'Weekly',
347     'Monthly'
348     );
349    
350    
351     # Default maximum visible URL length
352     $main::DefaultMaxVisibleUrlLength = 80;
353    
354    
355     #--------------------------------------------------------------------------
356     #
357     # Function: vSendHTMLHeader()
358     #
359     # Purpose: This function send the HTML header
360     #
361     # Called by:
362     #
363     # Parameters: $Title HTML page title
364     # $JavaScript JavaScript to send
365     #
366     # Global Variables: $main::HeaderSent
367     #
368     # Returns: void
369     #
370     sub vSendHTMLHeader {
371    
372     my ($Title, $JavaScript) = @_;
373    
374    
375     # Bail if we are not running as a CGI-BIN script
376     if ( ! $ENV{'GATEWAY_INTERFACE'} ) {
377     return;
378     }
379 dpavlin 1.4
380 dpavlin 1.1 # Bail if we have already sent the header
381     if ( $main::HeaderSent ) {
382     return;
383     }
384    
385    
386     # Send the CGI-BIN response header
387     print("Content-type: text/html\n\n");
388    
389     # Put out the html document header
390     printf("<HTML>\n<HEAD>\n<TITLE>\n%s\n</TITLE>\n", defined($Title) ? $Title : "FS Consulting - MPS Direct Search Interface");
391     if ( defined($JavaScript) ) {
392     print("$JavaScript\n");
393     }
394     print '<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-2">';
395 dpavlin 1.14 print '<link rel="STYLESHEET" type="text/css" href="'.$main::ConfigurationData{'image-base-path'}.'/stil.css">';
396 dpavlin 1.1 print("</HEAD>\n<BODY BGCOLOR=\"#FFFFFF\">\n");
397    
398    
399     # Send the header snippet file
400     &vPrintFileContent($main::ConfigurationData{'html-header-snippet-file'});
401    
402    
403     # Send the banner
404     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
405 dpavlin 1.5 # 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");
406    
407     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");
408    
409     print("</TABLE>\n");
410 dpavlin 1.1
411    
412     # Set the flag saying that the header has been sent
413     $main::HeaderSent = 1;
414    
415     return;
416    
417     }
418    
419    
420    
421     #--------------------------------------------------------------------------
422     #
423     # Function: vSendHTMLFooter()
424     #
425     # Purpose: This function send the HTML footer
426     #
427     # Called by:
428     #
429     # Parameters: void
430     #
431     # Global Variables: $main::FooterSent
432     #
433     # Returns: void
434     #
435     sub vSendHTMLFooter {
436    
437    
438     # Bail if we are not running as a CGI-BIN script
439     if ( ! $ENV{'GATEWAY_INTERFACE'} ) {
440     return;
441     }
442    
443     # Bail if we have already sent the footer
444     if ( $main::FooterSent ) {
445     return;
446     }
447    
448    
449     # Send the footer snippet file
450     &vPrintFileContent($main::ConfigurationData{'html-footer-snippet-file'});
451    
452    
453     # Send the end of body tag and end of HTML tag
454     print("</BODY>\n</HTML>\n");
455    
456    
457     # Set the flag saying that the footer has been sent
458     $main::FooterSent = 1;
459    
460     return;
461    
462     }
463    
464    
465    
466     #--------------------------------------------------------------------------
467     #
468     # Function: vSendMenuBar()
469     #
470     # Purpose: This function send the mneu bar
471     #
472     # Called by:
473     #
474     # Parameters: %MenuBar menu bar exclusion hash table
475     #
476     # Global Variables:
477     #
478     # Returns: void
479     #
480     sub vSendMenuBar {
481    
482     my (%MenuBar) = @_;
483    
484     my (%Value, $Value, $ValueEntry);
485    
486    
487     # Start the table
488     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
489    
490     # Start the menu bar cell
491     print("<TR><TD VALIGN=CENTER ALIGN=CENTER>\n");
492    
493     # Start the form
494     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
495    
496    
497    
498     # List the hidden fields
499     %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
500     foreach $Value ( keys(%Value) ) {
501     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
502     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
503     }
504     }
505    
506 dpavlin 1.12 my $DISABLED;
507 dpavlin 1.5
508 dpavlin 1.12 $DISABLED = ( %MenuBar && defined($MenuBar{'GetSearch'}) ) ? "DISABLED" : "";
509 dpavlin 1.16 print("<INPUT NAME=\"GetSearch\" TYPE=SUBMIT VALUE=\"Pretra¾ivanje\" $DISABLED class=\"navigacija${DISABLED}\">");
510 dpavlin 1.1
511     if ( defined($main::RemoteUser) ) {
512 dpavlin 1.12 $DISABLED = ( %MenuBar && defined($MenuBar{'ListSearchHistory'}) ) ? "DISABLED" : "";
513 dpavlin 1.16 print"<INPUT NAME=\"ListSearchHistory\" TYPE=SUBMIT VALUE=\"Prija¹nja pretra¾ivanja\" $DISABLED class=\"navigacija${DISABLED}\">";
514 dpavlin 1.1
515 dpavlin 1.12 $DISABLED = ( %MenuBar && defined($MenuBar{'ListSavedSearch'}) ) ? "DISABLED" : "";
516 dpavlin 1.16 print"<INPUT NAME=\"ListSavedSearch\" TYPE=SUBMIT VALUE=\"Spremljena pretra¾ivanja\" $DISABLED class=\"navigacija${DISABLED}\">";
517 dpavlin 1.1
518 dpavlin 1.12 $DISABLED = ( %MenuBar && defined($MenuBar{'ListFolder'}) ) ? "DISABLED" : "";
519 dpavlin 1.16 print"<INPUT NAME=\"ListFolder\" TYPE=SUBMIT VALUE=\"Korisnièki folderi\" $DISABLED class=\"navigacija${DISABLED}\">";
520 dpavlin 1.12
521     $DISABLED = ( %MenuBar && defined($MenuBar{'GetUserSettings'}) ) ? "DISABLED" : "";
522 dpavlin 1.16 print"<INPUT NAME=\"GetUserSettings\" TYPE=SUBMIT VALUE=\"Korisnièke postavke\" $DISABLED class=\"navigacija${DISABLED}\">";
523 dpavlin 1.1 }
524    
525    
526     print("</FORM>\n");
527    
528     # Close off the menu bar cell
529     print("</TD></TR>\n");
530    
531     print("</TABLE>\n");
532    
533    
534     return;
535     }
536    
537    
538    
539    
540    
541    
542     #--------------------------------------------------------------------------
543     #
544     # Function: vHandleError()
545     #
546     # Purpose: This function handles any errors messages that need to be
547     # reported when an error occurs
548     #
549     # This error handler also displays the header if needed
550     #
551     # Called by:
552     #
553     # Parameters: $Header header
554     # $Message message
555     #
556     # Global Variables:
557     #
558     # Returns: void
559     #
560     sub vHandleError {
561    
562     my ($Header, $Message) = @_;
563    
564     my ($Package, $FileName, $Line);
565    
566    
567     # Make sure we send the header
568     &vSendHTMLHeader("Error", undef);
569    
570    
571     printf("<H3> %s: </H3>\n", defined($Header) ? $Header : "No header supplied");
572     printf("<H3><CENTER> %s. </CENTER></H3>\n", defined($Message) ? $Message : "No error message supplied");
573     print("<P>\n");
574     if ( defined($main::ConfigurationData{'site-admin-url'}) ) {
575     print("<CENTER> Please <A HREF=\"$main::ConfigurationData{'site-admin-url'}\"> contact the administrator </A> of this system to correct the problem. </CENTER>\n");
576     }
577     else {
578     print("<CENTER> Please contact the administrator of this system to correct the problem. </CENTER>\n");
579     }
580     print("<P><HR WIDTH=50%><P>\n");
581    
582    
583     # Send package information
584     # ($Package, $FileName, $Line) = caller;
585     # print("Package = [$Package], FileName = [$FileName], Line = [$Line] <BR>\n");
586    
587     return;
588     }
589    
590    
591    
592    
593    
594     #--------------------------------------------------------------------------
595     #
596     # Function: bCheckConfiguration()
597     #
598     # Purpose: This function checks that the configuration settings
599     # specified are correct and that any directory paths and
600     # files specified are there and can be accessed.
601     #
602     # We check both required settings and optional setting if
603     # they have been set.
604     #
605     # An error here should be considered fatal.
606     #
607     # Called by:
608     #
609     # Parameters: void
610     #
611     # Global Variables: %main::ConfigurationData
612     #
613     # Returns: Boolean status
614     #
615     sub bCheckConfiguration {
616    
617     my ($Value, $Status);
618    
619    
620     # Init the status
621     $Status = 1;
622    
623    
624     # Check 'user-accounts-directory' (optional)
625     if ( defined($main::ConfigurationData{'user-accounts-directory'}) ) {
626    
627     $main::ConfigurationData{'user-accounts-directory'} = &sCleanSetting('user-accounts-directory', $main::ConfigurationData{'user-accounts-directory'}, $main::RootDirectoryPath);
628     $Value = $main::ConfigurationData{'user-accounts-directory'};
629    
630     # Check that the directory exists
631     if ( ! (-d $Value) ) {
632     &vLog("Error - configuration setting: 'user-accounts-directory', directory: '$Value' does not exist.\n");
633     $Status = 0;
634     }
635     else {
636    
637     # The directory exists, now check that it can be accessed
638     if ( ! ((-r $Value) && (-w $Value) && (-x $Value)) ) {
639     &vLog("Error - configuration setting: 'user-accounts-directory', directory: '$Value' cannot be accessed.\n");
640     $Status = 0;
641     }
642     }
643     }
644    
645    
646    
647     # Check 'database-description-file' (optional)
648     if ( defined($main::ConfigurationData{'database-description-file'}) ) {
649    
650     $main::ConfigurationData{'database-description-file'} = &sCleanSetting('database-description-file', $main::ConfigurationData{'database-description-file'}, $main::RootDirectoryPath);
651     $Value = $main::ConfigurationData{'database-description-file'};
652    
653     # Check that the file exists
654     if ( ! ((-f $Value) && (-r $Value)) ) {
655     &vLog("Error - configuration setting: 'database-description-file', file: '$Value' does not exist.\n");
656     $Status = 0;
657     }
658     }
659    
660    
661    
662     # Check 'allow-summary-displays' (optional)
663     if ( defined($main::ConfigurationData{'allow-summary-displays'}) ) {
664    
665     # Clean the setting and convert to lower case
666     $main::ConfigurationData{'allow-summary-displays'} = &sCleanSetting('allow-summary-displays', $main::ConfigurationData{'allow-summary-displays'});
667     $main::ConfigurationData{'allow-summary-displays'} = lc($main::ConfigurationData{'allow-summary-displays'});
668    
669     # Check that the setting is valid
670     if ( ($main::ConfigurationData{'allow-summary-displays'} ne "yes") && ($main::ConfigurationData{'allow-summary-displays'} ne "no")) {
671     &vLog("Warning - configuration setting: 'allow-summary-displays', setting not recognized: $main::ConfigurationData{'allow-summary-displays'}.\n");
672     }
673     }
674    
675    
676    
677     # Check 'allow-similiar-search' (optional)
678     if ( defined($main::ConfigurationData{'allow-similiar-search'}) ) {
679    
680     # Clean the setting and convert to lower case
681     $main::ConfigurationData{'allow-similiar-search'} = &sCleanSetting('allow-similiar-search', $main::ConfigurationData{'allow-similiar-search'});
682     $main::ConfigurationData{'allow-similiar-search'} = lc($main::ConfigurationData{'allow-similiar-search'});
683    
684     # Check that the setting is valid
685     if ( ($main::ConfigurationData{'allow-similiar-search'} ne "yes") && ($main::ConfigurationData{'allow-similiar-search'} ne "no")) {
686     &vLog("Warning - configuration setting: 'allow-similiar-search', setting not recognized: $main::ConfigurationData{'allow-similiar-search'}.\n");
687     }
688     }
689    
690    
691    
692     # Check 'allow-regular-searches' (optional)
693     if ( defined($main::ConfigurationData{'allow-regular-searches'}) ) {
694    
695     # Clean the setting and convert to lower case
696     $main::ConfigurationData{'allow-regular-searches'} = &sCleanSetting('allow-regular-searches', $main::ConfigurationData{'allow-regular-searches'});
697     $main::ConfigurationData{'allow-regular-searches'} = lc($main::ConfigurationData{'allow-regular-searches'});
698    
699     # Check that the setting is valid
700     if ( ($main::ConfigurationData{'allow-regular-searches'} ne "yes") && ($main::ConfigurationData{'allow-regular-searches'} ne "no")) {
701     &vLog("Warning - configuration setting: 'allow-regular-searches', setting not recognized: $main::ConfigurationData{'allow-regular-searches'}.\n");
702     }
703     }
704    
705    
706    
707     # Check 'deliver-empty-results-from-regular-search' (optional)
708     if ( defined($main::ConfigurationData{'deliver-empty-results-from-regular-search'}) ) {
709    
710     # Clean the setting and convert to lower case
711     $main::ConfigurationData{'deliver-empty-results-from-regular-search'} = &sCleanSetting('deliver-empty-results-from-regular-search', $main::ConfigurationData{'deliver-empty-results-from-regular-search'});
712     $main::ConfigurationData{'deliver-empty-results-from-regular-search'} = lc($main::ConfigurationData{'deliver-empty-results-from-regular-search'});
713    
714     # Check that the setting is valid
715     if ( ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} ne "yes") && ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} ne "no")) {
716     &vLog("Warning - configuration setting: 'deliver-empty-results-from-regular-search', setting not recognized: $main::ConfigurationData{'deliver-empty-results-from-regular-search'}.\n");
717     }
718     }
719    
720    
721    
722     # Check 'allow-relevance-feedback-searches' (optional)
723     if ( defined($main::ConfigurationData{'allow-relevance-feedback-searches'}) ) {
724    
725     # Clean the setting and convert to lower case
726     $main::ConfigurationData{'allow-relevance-feedback-searches'} = &sCleanSetting('allow-relevance-feedback-searches', $main::ConfigurationData{'allow-relevance-feedback-searches'});
727     $main::ConfigurationData{'allow-relevance-feedback-searches'} = lc($main::ConfigurationData{'allow-relevance-feedback-searches'});
728    
729     # Check that the setting is valid
730     if ( ($main::ConfigurationData{'allow-relevance-feedback-searches'} ne "yes") && ($main::ConfigurationData{'allow-relevance-feedback-searches'} ne "no")) {
731     &vLog("Warning - configuration setting: 'allow-relevance-feedback-searches', setting not recognized: $main::ConfigurationData{'allow-relevance-feedback-searches'}.\n");
732     }
733     }
734    
735    
736    
737     # Check 'html-directory' (required)
738     $main::ConfigurationData{'html-directory'} = &sCleanSetting('html-directory', $main::ConfigurationData{'html-directory'}, $main::RootDirectoryPath);
739     $Value = $main::ConfigurationData{'html-directory'};
740    
741     # Check that the directory exists
742     if ( ! (-d $Value) ) {
743     &vLog("Error - configuration setting: 'html-directory', directory: '$Value' does not exist.\n");
744     $Status = 0;
745     }
746     else {
747    
748     # The directory exists, now check that it can be accessed
749     if ( ! ((-r $Value) && (-x $Value)) ) {
750     &vLog("Error - configuration setting: 'html-directory', directory: '$Value' cannot be accessed.\n");
751     $Status = 0;
752     }
753     }
754    
755    
756    
757     # Check 'image-base-path' (required)
758     $main::ConfigurationData{'image-base-path'} = &sCleanSetting('image-base-path', $main::ConfigurationData{'image-base-path'});
759     $Value = $main::ConfigurationData{'html-directory'} . $main::ConfigurationData{'image-base-path'};
760    
761     # Check that the directory exists
762     if ( ! (-d $Value) ) {
763     &vLog("Error - configuration setting: 'image-base-path', directory: '$Value' does not exist.\n");
764     $Status = 0;
765     }
766     else {
767    
768     my ($ImageName);
769    
770     # The directory exists, now check that it can be accessed
771     if ( ! ((-r $Value) && (-x $Value)) ) {
772     &vLog("Error - configuration setting: 'image-base-path', directory: '$Value' cannot be accessed.\n");
773     $Status = 0;
774     }
775    
776    
777     # Check the general icons
778     foreach $ImageName ( values(%main::ImageNames) ) {
779    
780     $Value = $main::ConfigurationData{'html-directory'} . $main::ConfigurationData{'image-base-path'} . "/" . $ImageName;
781    
782     # Check that the file exists
783     if ( ! ((-f $Value) && (-r $Value)) ) {
784     &vLog("Error - configuration setting: 'image-base-path', file: '$Value' does not exist.\n");
785     $Status = 0;
786     }
787     }
788     }
789    
790    
791    
792     # Check 'html-header-snippet-file' (optional)
793     if ( defined($main::ConfigurationData{'html-header-snippet-file'}) ) {
794    
795     $main::ConfigurationData{'html-header-snippet-file'} = &sCleanSetting('html-header-snippet-file', $main::ConfigurationData{'html-header-snippet-file'}, $main::RootDirectoryPath);
796     $Value = $main::ConfigurationData{'html-header-snippet-file'};
797    
798     # Check that the file exists
799     if ( ! ((-f $Value) && (-r $Value)) ) {
800     &vLog("Error - configuration setting: 'html-header-snippet-file', file: '$Value' does not exist.\n");
801     $Status = 0;
802     }
803     }
804    
805    
806    
807     # Check 'html-footer-snippet-file' (optional)
808     if ( defined($main::ConfigurationData{'html-footer-snippet-file'}) ) {
809    
810     $main::ConfigurationData{'html-footer-snippet-file'} = &sCleanSetting('html-footer-snippet-file', $main::ConfigurationData{'html-footer-snippet-file'}, $main::RootDirectoryPath);
811     $Value = $main::ConfigurationData{'html-footer-snippet-file'};
812    
813     # Check that the file exists
814     if ( ! ((-f $Value) && (-r $Value)) ) {
815     &vLog("Error - configuration setting: 'html-footer-snippet-file', file: '$Value' does not exist.\n");
816     $Status = 0;
817     }
818     }
819    
820    
821    
822     # Check 'logs-directory' (required)
823     $main::ConfigurationData{'logs-directory'} = &sCleanSetting('logs-directory', $main::ConfigurationData{'logs-directory'}, $main::RootDirectoryPath);
824     $Value = $main::ConfigurationData{'logs-directory'};
825    
826     # Check that the directory exists
827     if ( ! (-d $Value) ) {
828     &vLog("Error - configuration setting: 'logs-directory', directory: '$Value' does not exist.\n");
829     $Status = 0;
830     }
831     else {
832    
833     # The directory exists, now check that it can be accessed
834     if ( ! ((-r $Value) && (-w $Value) && (-x $Value)) ) {
835     &vLog("Error - configuration setting: 'logs-directory', directory: '$Value' cannot be accessed.\n");
836     $Status = 0;
837     }
838     }
839    
840    
841    
842     # Check 'database-directory' (required)
843     $main::ConfigurationData{'database-directory'} = &sCleanSetting('database-directory', $main::ConfigurationData{'database-directory'}, $main::RootDirectoryPath);
844     $Value = $main::ConfigurationData{'database-directory'};
845    
846     # Check that the directory exists
847     if ( ! (-d $Value) ) {
848     &vLog("Error - configuration setting: 'database-directory', directory: '$Value' does not exist.\n");
849     $Status = 0;
850     }
851     else {
852    
853     # The directory exists, now check that it can be accessed
854     if ( ! ((-r $Value) && (-x $Value)) ) {
855     &vLog("Error - configuration setting: 'database-directory, directory: '$Value' cannot be accessed.\n");
856     $Status = 0;
857     }
858     }
859    
860    
861    
862     # Check 'configuration-directory' (required)
863     $main::ConfigurationData{'configuration-directory'} = &sCleanSetting('configuration-directory', $main::ConfigurationData{'configuration-directory'}, $main::RootDirectoryPath);
864     $Value = $main::ConfigurationData{'configuration-directory'};
865    
866     # Check that the directory exists
867     if ( ! (-d $Value) ) {
868     &vLog("Error - configuration setting: 'configuration-directory', directory: '$Value' does not exist.\n");
869     $Status = 0;
870     }
871     else {
872    
873     # The directory exists, now check that it can be accessed
874     if ( ! ((-r $Value) && (-x $Value)) ) {
875     &vLog("Error - configuration setting: 'configuration-directory, directory: '$Value' cannot be accessed.\n");
876     $Status = 0;
877     }
878     }
879    
880    
881    
882     # Check 'server-log' (optional with default)
883     $main::ConfigurationData{'server-log'} = &sCleanSetting('server-log', $main::ConfigurationData{'server-log'});
884     $Value = $main::ConfigurationData{'logs-directory'} . "/" . $main::ConfigurationData{'server-log'};
885    
886     # Check that we can write to the log file if it exists
887     if ( -f $Value ) {
888    
889     # The file exists, now check that it can be accessed
890     if ( ! -w $Value ) {
891     &vLog("Error - configuration setting: 'server-log', directory: '$Value' cannot be accessed.\n");
892     $Status = 0;
893     }
894     }
895    
896    
897    
898     # Check 'mailer-application' (optional with default)
899     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
900    
901     $main::ConfigurationData{'mailer-application'} = &sCleanSetting('mailer-application', $main::ConfigurationData{'mailer-application'}, $main::RootDirectoryPath);
902     $Value = $main::ConfigurationData{'mailer-application'};
903    
904     # Check that the application can be executed
905     if ( ! (-x $Value) ) {
906     &vLog("Error - configuration setting: 'mailer-application', application: '$Value' cannot be executed.\n");
907     $Status = 0;
908     }
909     }
910    
911    
912     return ($Status);
913    
914     }
915    
916    
917    
918    
919    
920     #--------------------------------------------------------------------------
921     #
922     # Function: bGetDatabaseDescriptions()
923     #
924     # Purpose: This function reads the database description file and places it in the
925     # hash table global, note that the hash table is not cleared before
926     # we start to add kay/value pairs to it.
927     #
928     # Any line which starts with a '#' or is empty will be skipped.
929     #
930     # An error will be generated if we try to redefine a value for a
931     # key that has already been defined.
932     #
933     # An error here should be considered fatal.
934     #
935     # Called by:
936     #
937     # Parameters: void
938     #
939     # Global Variables: %main::ConfigurationData, %main::DatabaseDescriptions
940     #
941     # Returns: Boolean status
942     #
943     sub bGetDatabaseDescriptions {
944    
945     my ($Status, $Key, $KeyValue, $KeyBase, $KeyLeaf, $Database);
946    
947    
948     # Init the status
949     $Status = 1;
950    
951    
952     # Only check the database description file if it is available
953     if ( defined($main::ConfigurationData{'database-description-file'}) ) {
954    
955     # Open the database description file
956     if ( ! open(FILE, "$main::ConfigurationData{'database-description-file'}") ) {
957     &vLog("Error - could not open database description file: '$main::ConfigurationData{'database-description-file'}'.\n");
958     return (0);
959     }
960    
961     # Read in each line in the file, ignore empty
962     # lines and lines which start with a '#'
963     while (<FILE>) {
964    
965     chop $_;
966    
967     # Check to see if this line is empty or is a comment, and skip them
968     if ( (length($_) == 0) || ($_ =~ /^#/) ) {
969     next;
970     }
971    
972     # Split the configuration string into a set of key/value pairs
973     ($Key, $KeyValue) = split(/=/, $_);
974    
975     # Only add values which are defined
976     if ( defined($KeyValue) && ($KeyValue ne "") ) {
977    
978     # Split the key into a key and a subkey
979     ($KeyBase, $KeyLeaf) = split(/:/, $Key, 2);
980    
981     if ( $KeyBase eq $main::DatabaseName ) {
982    
983     # Add the key/value pairs to the hash table
984     if ( defined($main::DatabaseDescriptions{$KeyLeaf}) ) {
985     # Fail if the value for this key is already defined
986     &vLog("Error - value for: '$KeyLeaf', is already defined as: '$main::DatabaseDescriptions{$KeyLeaf}', tried to redefine it to: '$KeyValue'.\n");
987     $Status = 0;
988     }
989     else {
990     # Add the value for this key
991     if ($KeyValue =~ s/(##sort[^#]+##)//) {
992     $main::DatabaseSort{$1} = $KeyLeaf;
993     } else {
994     $main::DatabaseSort{$KeyValue} = $KeyLeaf;
995     }
996     $main::DatabaseDescriptions{$KeyLeaf} = $KeyValue;
997     }
998     }
999     elsif ( $KeyBase eq $main::DatabaseFiltersPackage ) {
1000    
1001     # Add the key/value pairs to the hash table
1002     if ( defined($main::DatabaseFilters{$Key}) ) {
1003     # Fail if the value for this key is already defined
1004     &vLog("Error - value for: '$Key', is already defined as: '$main::DatabaseFilters{$Key}', tried to redefine it to: '$KeyValue'.\n");
1005     $Status = 0;
1006     }
1007     else {
1008    
1009     # Check that this filters package exists
1010     if ( ! -x $KeyValue ) {
1011     # Fail we cant find it
1012     &vLog("Error - filter: '$KeyValue' for: '$Key' could not be found.\n");
1013     $Status = 0;
1014     }
1015    
1016     # Add the value for this key
1017     $main::DatabaseFilters{$Key} = $KeyValue;
1018     }
1019     }
1020     else {
1021    
1022     ($Database) = split(/:/, $KeyLeaf);
1023    
1024     # Add the key/value pairs to the hash table
1025     if ( ! defined($main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Database"}) ) {
1026     # Fail if we dont have the package for this function
1027     &vLog("Error - package file for function: '$KeyValue', defined for: '$Key', cound not be found.\n");
1028     $Status = 0;
1029     }
1030     elsif ( defined($main::DatabaseFilters{$Key}) ) {
1031     # Fail if the value for this key is already defined
1032     &vLog("Error - value for: '$Key', is already defined as: '$main::DatabaseFilters{$Key}', tried to redefine it to: '$KeyValue'.\n");
1033     $Status = 0;
1034     }
1035     else {
1036    
1037     # Add the value for this key
1038     $main::DatabaseFilters{$Key} = $KeyValue;
1039     }
1040     }
1041     }
1042     }
1043     close(FILE);
1044     }
1045    
1046     # fill defaults for rest
1047     $main::DatabaseFilters{$Key} = $main::DatabaseFilters{default} if (! defined($main::DatabaseFilters{$Key}));
1048    
1049     return ($Status);
1050    
1051     }
1052    
1053    
1054    
1055    
1056    
1057     #--------------------------------------------------------------------------
1058     #
1059     # Function: bInitializeServer()
1060     #
1061     # Purpose: This function sets up the server
1062     #
1063     # An error here should be considered fatal.
1064     #
1065     # Called by:
1066     #
1067     # Parameters: void
1068     #
1069     # Global Variables: %main::ConfigurationData
1070     #
1071     # Returns: Boolean status
1072     #
1073     sub bInitializeServer {
1074    
1075     my ($Status, $Text);
1076     my ($ErrorNumber, $ErrorMessage);
1077    
1078    
1079     # Initialize the server
1080     ($Status, $Text) = MPS::InitializeServer($main::ConfigurationData{'database-directory'}, $main::ConfigurationData{'configuration-directory'}, $main::ConfigurationData{'logs-directory'} . "/". $main::ConfigurationData{'server-log'}, MPS_LOG_MEDIUM);
1081    
1082     # Check the return code
1083     if ( ! $Status ) {
1084     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Text, 2);
1085     &vHandleError("Database Search", "Sorry, failed to initialize the server");
1086     print("The following error message was reported: <BR>\n");
1087     print("Error Message: $ErrorMessage <BR>\n");
1088     print("Error Number: $ErrorNumber <BR>\n");
1089     }
1090    
1091     $main::MPSSession = $Text;
1092    
1093     return ($Status);
1094     }
1095    
1096    
1097    
1098    
1099    
1100     #--------------------------------------------------------------------------
1101     #
1102     # Function: bShutdownServer()
1103     #
1104     # Purpose: This function shuts down the server
1105     #
1106     # An error here should be considered fatal.
1107     #
1108     # Called by:
1109     #
1110     # Parameters: void
1111     #
1112     # Global Variables: %main::ConfigurationData
1113     #
1114     # Returns: Boolean status
1115     #
1116     sub bShutdownServer {
1117    
1118    
1119     # Shutdown the server
1120     MPS::ShutdownServer($main::MPSSession);
1121    
1122     return (1);
1123    
1124     }
1125    
1126    
1127    
1128    
1129    
1130     #--------------------------------------------------------------------------
1131     #
1132     # Function: bCheckCGIEnvironment()
1133     #
1134     # Purpose: This function checks that all the CGI environment variables we
1135     # need are available. It will exit if any of the variables are
1136     # not found, but it will first list all the variables that are
1137     # not available.
1138     #
1139     # An error here should be considered fatal.
1140     #
1141     # Called by:
1142     #
1143     # Parameters: void
1144     #
1145     # Global Variables: $ENV{}
1146     #
1147     # Returns: Boolean status
1148     #
1149     sub bCheckCGIEnvironment {
1150    
1151     my ($Status);
1152    
1153    
1154     # Init the status
1155     $Status = 1;
1156    
1157    
1158     # Check that REQUEST_METHOD is specified
1159     if ( ! (defined($ENV{'REQUEST_METHOD'}) && ($ENV{'REQUEST_METHOD'} ne "")) ) {
1160     &vLog("Error - missing 'REQUEST_METHOD' environment variable.\n");
1161     $Status = 0;
1162     }
1163    
1164    
1165     # Check that SCRIPT_NAME is specified
1166     if ( ! (defined($ENV{'SCRIPT_NAME'}) && ($ENV{'SCRIPT_NAME'} ne "")) ) {
1167     &vLog("Error - missing 'SCRIPT_NAME' environment variable.\n");
1168     $Status = 0;
1169     }
1170    
1171    
1172     # Force guest
1173     #$ENV{'REMOTE_USER'} = "guest";
1174    
1175     # Make sure that REMOTE_USER is defined, we set it to an empty string if it is not
1176     if ( ! (defined($ENV{'REMOTE_USER'}) && ($ENV{'REMOTE_USER'} ne "")) ) {
1177     $ENV{'REMOTE_USER'} = "";
1178     }
1179     else {
1180     # REMOTE_USER is defined, we check to see if the guest account name is defined
1181     if ( defined($main::ConfigurationData{'guest-account-name'}) ) {
1182     # Set the REMOTE_USER to an empty string if it is the same as the guest account
1183     if ( $ENV{'REMOTE_USER'} eq $main::ConfigurationData{'guest-account-name'} ) {
1184     $ENV{'REMOTE_USER'} = "";
1185     }
1186     }
1187     }
1188    
1189    
1190     # Adjust the path info if needed
1191     if ( defined($ENV{'PATH_INFO'}) && defined($ENV{'SCRIPT_NAME'}) && (length($ENV{'PATH_INFO'}) > length($ENV{'SCRIPT_NAME'})) ) {
1192     if ( substr($ENV{'PATH_INFO'}, 0, length($ENV{'SCRIPT_NAME'})) eq $ENV{'SCRIPT_NAME'} ) {
1193     $ENV{'PATH_INFO'} = substr($ENV{'PATH_INFO'}, length($ENV{'SCRIPT_NAME'}));
1194     $ENV{'PATH_INFO'} = undef if ($ENV{'PATH_INFO'} eq "");
1195     }
1196     }
1197    
1198    
1199     return ($Status);
1200    
1201     }
1202    
1203    
1204    
1205    
1206     #--------------------------------------------------------------------------
1207     #
1208     # Function: bSetupCGIEnvironment()
1209     #
1210     # Purpose: This function sets up the environment for the CGI mode, it will
1211     # also check that all the globals are correct and that any
1212     # required directories can be accessed and written to
1213     #
1214     # An error here should be considered fatal.
1215     #
1216     # Called by:
1217     #
1218     # Parameters: void
1219     #
1220     # Global Variables: $main::UserAccountDirectoryPath, $main::UserSettingsFilePath, $main::RemoteUser,
1221     # %main::FormData, %main::ConfigurationData
1222     #
1223     # Returns: Boolean status
1224     #
1225     sub bSetupCGIEnvironment {
1226    
1227     my ($Status, $URLString);
1228    
1229    
1230     # Init the status
1231     $Status = 1;
1232    
1233    
1234     # Get the query string from the environment
1235     if ( $ENV{'REQUEST_METHOD'} eq "GET" ) {
1236     $URLString = $ENV{'QUERY_STRING'};
1237     }
1238     # Get the query string from stdin
1239     elsif ( $ENV{'REQUEST_METHOD'} eq "POST" ) {
1240     read("STDIN", $URLString, $ENV{'CONTENT_LENGTH'});
1241    
1242     # Append the query string if it is defined
1243     if ( defined($ENV{'QUERY_STRING'}) && ($ENV{'QUERY_STRING'} ne "") ) {
1244     $URLString = $ENV{'QUERY_STRING'} . "&". $URLString;
1245     }
1246     }
1247    
1248    
1249     # Parse the form data that was passed
1250     if ( defined($URLString) && ($URLString ne "") ) {
1251     %main::FormData = &hParseURLIntoHashTable($URLString);
1252     }
1253    
1254    
1255     # Get the REMOTE_USER from the CGI environment and set the user account directory path
1256     if ( (defined($ENV{'REMOTE_USER'})) && ($ENV{'REMOTE_USER'} ne "") && defined($main::ConfigurationData{'user-accounts-directory'}) ) {
1257     $main::RemoteUser = $ENV{'REMOTE_USER'};
1258     $main::UserAccountDirectoryPath = $main::ConfigurationData{'user-accounts-directory'} . "/". $main::RemoteUser;
1259     $main::UserAccountDirectoryPath =~ tr/\+/ /;
1260     $main::UserSettingsFilePath = $main::UserAccountDirectoryPath . "/". $main::UserSettingsFileName . $main::XMLFileNameExtension;
1261     }
1262     else {
1263     undef($main::RemoteUser);
1264     undef($main::UserAccountDirectoryPath);
1265     undef($main::UserSettingsFilePath);
1266     }
1267    
1268    
1269     # Check that the user account directory exists if it is specified
1270     if ( defined($main::UserAccountDirectoryPath) ) {
1271    
1272     # Try to create the user account directory if it does not exist
1273     if ( ! -d $main::UserAccountDirectoryPath ) {
1274    
1275     if ( mkdir($main::UserAccountDirectoryPath, 0700) ) {
1276    
1277     # Set the user account directory so that it can be accessed by ourselves only
1278     chmod(0700, $main::UserAccountDirectoryPath);
1279    
1280     }
1281     else {
1282    
1283     # The directory could not be created, so we inform the user of the fact
1284     &vHandleError("User Account Error", "Sorry, the account directory could not be created");
1285     $Status = 0;
1286     }
1287     }
1288    
1289    
1290     # Check that we can access user account directory
1291     if ( ! ((-r $main::UserAccountDirectoryPath) && (-w $main::UserAccountDirectoryPath) && (-x $main::UserAccountDirectoryPath)) ) {
1292    
1293     # The directory cannot be accessed, so we inform the user of the fact
1294     &vHandleError("User Account Error", "Sorry, the account directory could not be accessed");
1295     $Status = 0;
1296     }
1297     }
1298    
1299    
1300     return ($Status);
1301    
1302     }
1303    
1304    
1305    
1306    
1307     #--------------------------------------------------------------------------
1308     #
1309     # Function: sMakeSearchURL()
1310     #
1311     # Purpose: This function makes a search URL from the passed content hash.
1312     #
1313     # Called by:
1314     #
1315     # Parameters: %Content content hash
1316     #
1317     # Global Variables: none
1318     #
1319     # Returns: the URL search string, and an empty string if
1320     # nothing relevant is defined in the content
1321     #
1322     sub sMakeSearchURL {
1323    
1324     my (%Content) = @_;
1325    
1326     my ($SearchURL, $Value);
1327     my (@InternalFieldNames) = ('Any', 'Operator', 'Past', 'Since', 'Before', 'LastRunTime', 'Order', 'Max', 'Database');
1328    
1329    
1330     # Initialize the search URL
1331     $SearchURL = "";
1332    
1333    
1334     # Add the generic field names
1335     foreach $Value ( 1..100 ) {
1336    
1337     my ($FieldName) = "FieldName" . $Value;
1338     my ($FieldContent) = "FieldContent" . $Value;
1339    
1340     if ( defined($Content{$FieldName}) ) {
1341     $SearchURL .= "&$FieldName=" . &lEncodeURLData($Content{$FieldName});
1342     $SearchURL .= defined($Content{$FieldContent}) ? "&$FieldContent=" . &lEncodeURLData($Content{$FieldContent}) : "";
1343     }
1344     }
1345    
1346    
1347     # Add the internal search terms
1348     foreach $Value ( @InternalFieldNames ) {
1349     $SearchURL .= defined($Content{$Value}) ? "&$Value=" . join("&$Value=", &lEncodeURLData(split(/\0/, $Content{$Value}))) : "";
1350     }
1351    
1352    
1353     # Return the URL, choping out the initial '&'
1354     return (($SearchURL ne "") ? substr($SearchURL, 1) : "");
1355    
1356     }
1357    
1358    
1359    
1360    
1361    
1362     #--------------------------------------------------------------------------
1363     #
1364     # Function: sMakeDocumentURL()
1365     #
1366     # Purpose: This function makes a document URL from the passed content hash.
1367     #
1368     # Called by:
1369     #
1370     # Parameters: %Content content hash
1371     #
1372     # Global Variables: none
1373     #
1374     # Returns: the URL document string, and an empty string if
1375     # nothing relevant is defined in the content
1376     #
1377     sub sMakeDocumentURL {
1378    
1379     my (%Content) = @_;
1380    
1381     my ($DocumentURL);
1382    
1383    
1384     # Initialize the document URL
1385     $DocumentURL = "";
1386    
1387    
1388     # Add the document URLs
1389     if ( defined($Content{'Document'}) ) {
1390     $DocumentURL .= "&Document=" . join("&Document=", &lEncodeURLData(split(/\0/, $Content{'Document'})));
1391     }
1392    
1393    
1394     # Return the URL, choping out the initial '&'
1395     return (($DocumentURL ne "") ? substr($DocumentURL, 1) : "");
1396    
1397     }
1398    
1399    
1400    
1401    
1402    
1403     #--------------------------------------------------------------------------
1404     #
1405     # Function: sMakeRfDocumentURL()
1406     #
1407     # Purpose: This function makes an RF document URL from the passed content hash.
1408     #
1409     # Called by:
1410     #
1411     # Parameters: %Content content hash
1412     #
1413     # Global Variables: none
1414     #
1415     # Returns: the URL RF document string, and an empty string if
1416     # nothing relevant is defined in the content
1417     #
1418     sub sMakeRfDocumentURL {
1419    
1420     my (%Content) = @_;
1421    
1422     my ($RfDocumentURL);
1423    
1424    
1425     # Initialize the RF document URL
1426     $RfDocumentURL = "";
1427    
1428    
1429     # Add the RF document URLs
1430     if ( defined($Content{'RfDocument'}) ) {
1431     $RfDocumentURL .= "&RfDocument=" . join("&RfDocument=", &lEncodeURLData(split(/\0/, $Content{'RfDocument'})));
1432     }
1433    
1434    
1435     # Return the URL, choping out the initial '&'
1436     return (($RfDocumentURL ne "") ? substr($RfDocumentURL, 1) : "");
1437    
1438     }
1439    
1440    
1441    
1442    
1443    
1444     #--------------------------------------------------------------------------
1445     #
1446     # Function: sMakeSearchAndRfDocumentURL()
1447     #
1448     # Purpose: This function makes a URL string from the search
1449     # and RF document URLs
1450     #
1451     # Called by:
1452     #
1453     # Parameters: %Content content hash
1454     #
1455     # Global Variables: none
1456     #
1457     # Returns: the URL query string, and an empty string if
1458     # nothing relevant is defined in %Content
1459     #
1460     sub sMakeSearchAndRfDocumentURL {
1461    
1462     my (%Content) = @_;
1463    
1464     my ($SearchURL, $RfDocumentURL, $SearchRfDocumentURL);
1465    
1466    
1467     # Get the search URL and the RF document URL
1468     $SearchURL = &sMakeSearchURL(%Content);
1469     $RfDocumentURL = &sMakeRfDocumentURL(%Content);
1470    
1471    
1472     # Concatenate them intelligently
1473     $SearchRfDocumentURL = $SearchURL . ((($SearchURL ne "") && ($RfDocumentURL ne "")) ? "&" : "") . $RfDocumentURL;
1474    
1475    
1476     # Return the URL
1477     return ($SearchRfDocumentURL);
1478    
1479     }
1480    
1481    
1482    
1483    
1484     #--------------------------------------------------------------------------
1485     #
1486     # Function: sMakeSearchString()
1487     #
1488     # Purpose: This function makes a search string from the search
1489     # variables in the content hash
1490     #
1491     # Called by:
1492     #
1493     # Parameters: %Content content hash
1494     #
1495     # Global Variables: void
1496     #
1497     # Returns: the search string, and an empty string if
1498     # nothing relevant is defined in the content hash
1499     #
1500     sub sMakeSearchString {
1501    
1502     my (%Content) = @_;
1503    
1504     my ($SearchString);
1505     my ($FieldName, $Time, $Date);
1506     my ($Value);
1507    
1508    
1509     # Initialize the search string
1510     $SearchString = "";
1511    
1512    
1513     # Add the search terms
1514     $SearchString .= defined($Content{'Any'}) ? ((($SearchString ne "") ? " AND " : "") . $Content{'Any'}) : "";
1515    
1516    
1517     # Add the generic field names
1518     foreach $Value ( 1..100 ) {
1519    
1520     my ($FieldName) = "FieldName" . $Value;
1521     my ($FieldContent) = "FieldContent" . $Value;
1522    
1523    
1524     if ( defined($Content{$FieldName}) ) {
1525     $SearchString .= defined($Content{$FieldContent}) ?
1526     (($SearchString ne "") ? " AND " : "") . "$Content{$FieldName}=(" . $Content{$FieldContent} . ")" : "";
1527     }
1528     }
1529    
1530     # nuke accented chars
1531     $SearchString =~ tr/Çüéâäùæç³ëÕõî¬ÄÆÉÅåôö¥µ¦¶ÖÜ«»£èáíóú¡±®¾Êê¼ÈºÁÂ̪¯¿ÃãðÐÏËïÒÍÎìÞÙÓÔÑñò©¹ÀÚàÛýÝþ´­½²·¢¸¨ÿØø/CueaauccleOoiZACELlooLlSsOUTtLcaiouAaZzEezCsAAESZzAadDDEdNIIeTUOoNnnSsRUrUyYt'-".'',"'Rr/;
1532 dpavlin 1.11 # convert search string to lower case -> make search case insensitive
1533     $SearchString =~ tr/A-Z/a-z/;
1534 dpavlin 1.1
1535     # Add the internal search terms
1536    
1537    
1538     # Add the date restriction on the load time
1539     if ( defined($Content{'LastRunTime'}) && ($Content{'LastRunTime'} > 0) ) {
1540     $SearchString .= (($SearchString ne "") ? " AND " : "") . "time_t>=$Content{'LastRunTime'}";
1541     }
1542    
1543    
1544     # Add the Past date restriction
1545     if ( defined($Content{'Past'}) && ($Content{'Past'} ne "0") ) {
1546    
1547     $Time = time();
1548     if ( $Content{'Past'} eq "Day" ) {
1549     $Time = &tSubstractFromTime($Time, undef, undef, 1);
1550     }
1551     elsif ( $Content{'Past'} eq "Week" ) {
1552     $Time = &tSubstractFromTime($Time, undef, undef, 7);
1553     }
1554     elsif ( $Content{'Past'} eq "Month" ) {
1555     $Time = &tSubstractFromTime($Time, undef, 1, undef);
1556     }
1557     elsif ( $Content{'Past'} eq "3 Months" ) {
1558     $Time = &tSubstractFromTime($Time, undef, 3, undef);
1559     }
1560     elsif ( $Content{'Past'} eq "6 Months" ) {
1561     $Time = &tSubstractFromTime($Time, undef, 6, undef);
1562     }
1563     elsif ( $Content{'Past'} eq "9 Months" ) {
1564     $Time = &tSubstractFromTime($Time, undef, 9, undef);
1565     }
1566     elsif ( $Content{'Past'} eq "Year" ) {
1567     $Time = &tSubstractFromTime($Time, 1, undef undef);
1568     }
1569    
1570     # Create an ANSI format date/time field
1571     $Date = &sGetAnsiDateFromTime($Time);
1572     $SearchString .= " {DATE>=$Date}";
1573     }
1574    
1575    
1576     # Add the Since date restriction
1577     if ( defined($Content{'Since'}) && ($Content{'Since'} ne "0") ) {
1578     $SearchString .= " {DATE>=$Content{'Since'}0000}";
1579     }
1580    
1581    
1582     # Add the Before date restriction
1583     if ( defined($Content{'Before'}) && ($Content{'Before'} ne "0") ) {
1584     $SearchString .= " {DATE<$Content{'Before'}0000}";
1585     }
1586    
1587    
1588     # Add the document sort order
1589     $SearchString .= defined($Content{'Order'}) ? " {" . $Content{'Order'} . "}" : "";
1590    
1591     # Add the operator
1592     $SearchString .= defined($Content{'Operator'}) ? " {" . $Content{'Operator'} . "}" : "";
1593    
1594    
1595     return (($SearchString ne "") ? $SearchString : undef);
1596    
1597     }
1598    
1599    
1600    
1601    
1602    
1603     #--------------------------------------------------------------------------
1604     #
1605     # Function: hGetSearchStringHash()
1606     #
1607     # Purpose: This function makes a search string hash table from the search
1608     # variables in the content hash
1609     #
1610     # Called by:
1611     #
1612     # Parameters: %Content content hash
1613     #
1614     # Global Variables: void
1615     #
1616     # Returns: the search string hash table, and an empty string if
1617     # nothing relevant is defined in the content hash
1618     #
1619     sub hGetSearchStringHash {
1620    
1621     my (%Content) = @_;
1622    
1623     my ($Content);
1624     my (%Value, @Values, $Value);
1625    
1626    
1627     @Values = split(/ /, defined($Content{'Any'}) ? $Content{'Any'} : "");
1628     foreach $Value ( @Values ) { $Value = lc($Value); $Value{$Value} = $Value };
1629    
1630    
1631     # Add the generic field names
1632     foreach $Value ( 1..100 ) {
1633    
1634     my ($FieldName) = "FieldName" . $Value;
1635     my ($FieldContent) = "FieldContent" . $Value;
1636    
1637     if ( defined($Content{$FieldName}) ) {
1638     @Values = split(/ /, defined($Content{$FieldContent}) ? $Content{$FieldContent} : "");
1639     foreach $Value ( @Values ) { $Value = lc($Value); $Value{$Value} = $Value };
1640     }
1641     }
1642    
1643    
1644     return (%Value);
1645    
1646     }
1647    
1648    
1649    
1650    
1651    
1652     #--------------------------------------------------------------------------
1653     #
1654     # Function: hGetDocumentFolders()
1655     #
1656     # Purpose: This function returns a hash table of all the document folders
1657     #
1658     # Called by:
1659     #
1660     # Parameters: void
1661     #
1662     # Global Variables: void
1663     #
1664     # Returns: a hash table of document folders, the key being the folder name
1665     # and the content being the folder file name
1666     #
1667     sub hGetDocumentFolders {
1668    
1669     my (@DocumentFolderList, $DocumentFolderEntry, $HeaderName, $FolderName, %QualifiedDocumentFolders);
1670    
1671     # Read all the document folder files
1672     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
1673     @DocumentFolderList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::DocumentFolderFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
1674     closedir(USER_ACCOUNT_DIRECTORY);
1675    
1676    
1677     # Loop over each document folder file checking that it is valid
1678     for $DocumentFolderEntry ( @DocumentFolderList ) {
1679    
1680     # Get the header name from the XML document folder file
1681     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderEntry);
1682    
1683     # Check that the entry is valid and add it to the qualified list
1684     if ( defined($HeaderName) && ($HeaderName eq "DocumentFolder") ) {
1685     $FolderName = &sGetTagValueFromXMLFile($DocumentFolderEntry, "FolderName");
1686     $QualifiedDocumentFolders{$FolderName} = $DocumentFolderEntry;
1687     }
1688     else {
1689     # Else we delete this invalid document folder file
1690     unlink($DocumentFolderEntry);
1691     }
1692     }
1693    
1694    
1695     return (%QualifiedDocumentFolders);
1696    
1697     }
1698    
1699    
1700    
1701    
1702    
1703     #--------------------------------------------------------------------------
1704     #
1705     # Function: iSaveSearchHistory()
1706     #
1707     # Purpose: This function saves the passed search to a new
1708     # search history XML file.
1709     #
1710     # Called by:
1711     #
1712     # Parameters: $FileName search history file name ('undef' means create a new file name)
1713     # $SearchAndRfDocumentURL search and RF document URL
1714     # $SearchResults search results
1715     # $QueryReport query report
1716     #
1717     # Global Variables: $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
1718     # $main::SearchHistoryFileNamePrefix
1719     #
1720     # Returns: 0 on error, 1 on success
1721     #
1722     sub iSaveSearchHistory {
1723    
1724     my ($FileName, $SearchAndRfDocumentURL, $SearchResults, $QueryReport) = @_;
1725     my ($SearchHistoryFilePath, %Value);
1726     my ($AnsiDateTime);
1727    
1728    
1729     # Return an error if the user account directory is not defined
1730     if ( !(defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
1731     return (0);
1732     }
1733    
1734     # Create a file name if one was not passed
1735     if ( !defined($FileName) ) {
1736     $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
1737     $SearchHistoryFilePath = $main::UserAccountDirectoryPath . "/". $main::SearchHistoryFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
1738     }
1739     else {
1740     $SearchHistoryFilePath = $FileName;
1741     }
1742    
1743    
1744     # Set the hash from the history information
1745     undef(%Value);
1746     $Value{'CreationTime'} = time();
1747     $Value{'SearchAndRfDocumentURL'} = $SearchAndRfDocumentURL;
1748     $Value{'QueryReport'} = $QueryReport;
1749     $Value{'SearchResults'} = $SearchResults;
1750    
1751    
1752     # Save the search information
1753     if ( ! &iSaveXMLFileFromHash($SearchHistoryFilePath, "SearchHistory", %Value) ) {
1754     # Failed to save the information, so we return an error
1755     return (0);
1756     }
1757    
1758     return (1);
1759    
1760     }
1761    
1762    
1763    
1764    
1765    
1766     #--------------------------------------------------------------------------
1767     #
1768     # Function: iSaveSearch()
1769     #
1770     # Purpose: This function saves the passed search to a new
1771     # search XML file.
1772     #
1773     # Called by:
1774     #
1775     # Parameters: $FileName saved search file name ('undef' means create a new file name)
1776     # $SearchName search name
1777     # $SearchDescription search description
1778     # $SearchAndRfDocumentURL search and RF document URL
1779     # $SearchFrequency search frequency
1780     # $DeliveryFormat delivery format
1781     # $DeliveryMethod delivery method
1782     # $SearchStatus search status
1783     # $CreationTime creation time
1784     # $LastRunTime last run time
1785     #
1786     # Global Variables: $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
1787     # $main::SavedSearchFileNamePrefix
1788     #
1789     # Returns: 0 on error, 1 on success
1790     #
1791     sub iSaveSearch {
1792    
1793     my ($FileName, $SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $LastRunTime) = @_;
1794     my ($SavedSearchFilePath, %Value);
1795     my ($AnsiDateTime);
1796    
1797    
1798     # Return an error if the user account directory is not defined
1799     if ( !(defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
1800     return (0);
1801     }
1802    
1803     # Create a file name if one was not passed
1804     if ( !defined($FileName) ) {
1805     $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
1806     $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/". $main::SavedSearchFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
1807     }
1808     else {
1809     $SavedSearchFilePath = $FileName;
1810     }
1811    
1812    
1813    
1814     # Set the hash from the search information
1815     undef(%Value);
1816     $Value{'SearchName'} = $SearchName;
1817     $Value{'SearchDescription'} = $SearchDescription;
1818     $Value{'SearchAndRfDocumentURL'} = $SearchAndRfDocumentURL;
1819     $Value{'SearchFrequency'} = $SearchFrequency;
1820     $Value{'DeliveryFormat'} = $DeliveryFormat;
1821     $Value{'DeliveryMethod'} = $DeliveryMethod;
1822     $Value{'SearchStatus'} = $SearchStatus;
1823     $Value{'CreationTime'} = $CreationTime;
1824     $Value{'LastRunTime'} = $LastRunTime;
1825    
1826    
1827     # Save the search information
1828     if ( ! &iSaveXMLFileFromHash($SavedSearchFilePath, "SavedSearch", %Value) ) {
1829     # Failed to save the information, so we return an error
1830     return (0);
1831     }
1832    
1833     return (1);
1834    
1835     }
1836    
1837    
1838    
1839    
1840    
1841     #--------------------------------------------------------------------------
1842     #
1843     # Function: iSaveFolder()
1844     #
1845     # Purpose: This function saves the passed folder to a new
1846     # document folder XML file.
1847     #
1848     # Called by:
1849     #
1850     # Parameters: $FileName document folder file name ('undef' means create a new file name)
1851     # $FolderName folder name
1852     # $FolderDescription folder description
1853     # $FolderDocuments folder document
1854     # $CreationTime creation time
1855     # $UpdateTime update time
1856     #
1857     # Global Variables: $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
1858     # $main::DocumentFolderFileNamePrefix
1859     #
1860     # Returns: 0 on error, 1 on success
1861     #
1862     sub iSaveFolder {
1863    
1864     my ($FileName, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) = @_;
1865     my ($DocumentFolderFilePath, %Value);
1866     my ($AnsiDateTime);
1867    
1868    
1869     # Return an error if the user account directory is not defined
1870     if ( !defined($main::RemoteUser) || !defined($main::UserAccountDirectoryPath) ) {
1871     return (0);
1872     }
1873    
1874     # Create a file name if one was not passed
1875     if ( !defined($FileName) ) {
1876     $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
1877     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/". $main::DocumentFolderFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
1878     }
1879     else {
1880     $DocumentFolderFilePath = $FileName;
1881     }
1882    
1883    
1884    
1885     # Set the hash from the folder information
1886     undef(%Value);
1887     $Value{'FolderName'} = $FolderName;
1888     $Value{'FolderDescription'} = $FolderDescription;
1889     $Value{'FolderDocuments'} = $FolderDocuments;
1890     $Value{'CreationTime'} = $CreationTime;
1891     $Value{'UpdateTime'} = $UpdateTime;
1892    
1893    
1894     # Save the document folder information
1895     if ( ! &iSaveXMLFileFromHash($DocumentFolderFilePath, "DocumentFolder", %Value) ) {
1896     # Failed to save the information, so we return an error
1897     return (0);
1898     }
1899    
1900     return (1);
1901    
1902     }
1903    
1904    
1905    
1906    
1907    
1908     #--------------------------------------------------------------------------
1909     #
1910     # Function: bDisplayDocuments()
1911     #
1912     # Purpose: This function displays the document
1913     #
1914     # Called by:
1915     #
1916     # Parameters: $Title title
1917     # $Documents \0 separated document URL
1918     # $FieldName field name
1919     # $Selector true to display selector
1920     # $Selected selector is selected
1921     # $HTML true to display HTML
1922     #
1923     #
1924     # Global Variables: void
1925     #
1926     # Returns: the status
1927     #
1928     sub bDisplayDocuments {
1929    
1930     my ($Title, $Documents, $FieldName, $Selector, $Selected, $HTML) = @_;
1931    
1932     my (@Documents, $Document, $Status, $DocumentInfo, $SelectorText, $SelectedText, $LinkText);
1933     my ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder);
1934     my (%Value, $Value, @Values);
1935    
1936    
1937     # Check input parameters
1938     if ( !defined($Documents) ) {
1939     return (0);
1940     }
1941    
1942    
1943     # Split the documents text into a documents list
1944     @Documents = split(/\0/, $Documents);
1945    
1946    
1947     # Set the field name
1948     $FieldName = (defined($FieldName ) && ($FieldName ne "")) ? $FieldName : "Document";
1949    
1950     # Set the selected text
1951     $SelectedText = ((defined($Selector) && $Selector) && (defined($Selected) && $Selected)) ? "CHECKED" : "";
1952    
1953    
1954     # Print the title
1955     if ( $HTML ) {
1956     printf("<TD ALIGN=LEFT VALIGN=TOP>%s%s:</TD><TD ALIGN=LEFT VALIGN=TOP>\n",
1957     defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
1958     }
1959     else {
1960     printf("%s%s:\n", defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
1961     }
1962    
1963    
1964     # Loop over each entry in the documents list
1965     foreach $Document ( @Documents ) {
1966    
1967     # Parse out the document entry
1968     %Value = &hParseURLIntoHashTable($Document);
1969    
1970     # Get the document information
1971     ($Status, $DocumentInfo) = MPS::GetDocumentInfo($main::MPSSession, $Value{'Database'}, $Value{'DocumentID'});
1972    
1973     if ( $Status ) {
1974     ($Headline, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $DocumentInfo, 8);
1975    
1976     # Decode the headline and strip the HTML
1977     $Headline = &lDecodeURLData($Headline);
1978     $Headline =~ s/&nbsp;//gs;
1979     $Headline =~ s/<.*?>//gs;
1980     $Headline =~ s/\s+/ /gs;
1981    
1982     # Create a generic link for this document
1983     $Value = "";
1984     $Value .= (defined($Value{'Database'}) && ($Value{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Value{'Database'}) : "";
1985     $Value .= (defined($Value{'DocumentID'}) && ($Value{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Value{'DocumentID'}) : "";
1986     $Value .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
1987     $Value .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
1988    
1989    
1990     # Create the selector text
1991     if ( defined($Selector) && $Selector ) {
1992     $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"$FieldName\" VALUE=\"" . substr($Value, 1) . "\" $SelectedText> ";
1993     }
1994     else {
1995     $SelectorText = " - ";
1996     }
1997    
1998     # Create the link text, we use the URL if it is there
1999     if ( defined($URL) && ($URL ne "") ) {
2000     $LinkText = $URL;
2001     }
2002     elsif ( defined($Value{'DocumentID'}) && ($Value{'DocumentID'} ne "") ) {
2003     $LinkText = "$ENV{'SCRIPT_NAME'}/GetDocument?" . substr($Value, 1);
2004     }
2005     else {
2006     $LinkText = "";
2007     }
2008    
2009     # Put up the headline and the score, this one links to the document
2010     if ( $HTML ) {
2011     print("$SelectorText <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline <I> ( $main::DatabaseDescriptions{$Value{'Database'}} ) </I> </A> <BR>\n");
2012    
2013     # if ( defined($URL) && ($URL ne "") ) {
2014     # $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
2015     # print("<FONT SIZE=-2><A HREF=\"$URL\"> $Value </A></FONT><BR>\n");
2016     # }
2017     }
2018     else {
2019     print("- $Headline ($main::DatabaseDescriptions{$Value{'Database'}})\n URL: $LinkText\n");
2020     }
2021     }
2022     }
2023    
2024     if ( $HTML ) {
2025     print("</TD>\n");
2026     }
2027    
2028    
2029     return (1);
2030    
2031     }
2032    
2033    
2034    
2035    
2036    
2037    
2038     #--------------------------------------------------------------------------
2039     #
2040     # Function: bsDisplaySearchResults()
2041     #
2042     # Purpose: This function displays the search results
2043     #
2044     # Called by:
2045     #
2046     # Parameters: $Title title
2047     # $SearchResults search results
2048     # $SearchDate search date
2049     # $SearchFrequency search frequency
2050     # $SearchDescription search description
2051     # $QueryReport query report
2052     # $ScriptName script name
2053     # $Header true to display header
2054     # $Selector true to display selector
2055     # $HTML true to display HTML
2056     # %Content content hash table
2057     #
2058     #
2059     # Global Variables: %main::ConfigurationData, $main::RemoteUser,
2060     # $main::QueryReportItemName, $main::QueryReportMimeType
2061     #
2062     # Returns: the status and a the query report
2063     #
2064     sub bsDisplaySearchResults {
2065    
2066     my ($Title, $SearchDescription, $SearchDate, $SearchFrequency, $SearchResults, $QueryReport, $ScriptName, $Header, $Selector, $HTML, %Content) = @_;
2067    
2068     my ($SearchString, $SummaryType, $SummaryLength, @SearchResults, $SearchResult, $FinalQueryReport, $ResultCount, %SearchStringHash);
2069     my ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder);
2070     my ($Status, $Text, $MimeTypeName, $SummaryText, $SelectorText, $LinkText, $RuleFlag, $LastItemName);
2071     my (@DocumentFolderList, %QualifiedDocumentFolders, $DocumentFolderEntry, $HeaderName, $FolderName, $Index);
2072     my (@Words, $Word, @OffsetPairs, $OffsetPair, %Offsets, $Offset, $Start, $End, $OldStart, $OldEnd, $CurrentSummaryLength);
2073     my ($DatabaseSummaryFilterKey, $DatabaseSummaryFilterFunction);
2074     my ($Value, %Value, @Values, $ValueEntry);
2075 dpavlin 1.9
2076    
2077 dpavlin 1.1 # Check input parameters
2078     if ( !defined($SearchResults) || !%Content ) {
2079     return (0);
2080     }
2081    
2082     # Split the search results text into a search results list
2083     @SearchResults = split(/\n/, $SearchResults);
2084    
2085    
2086     # First we count up the number of results and scoop up
2087     # any query reports if we need to
2088    
2089     # Initialize the final query report
2090     if ( !defined($QueryReport) ) {
2091     $FinalQueryReport = "";
2092     }
2093     else {
2094     $FinalQueryReport = $QueryReport;
2095     }
2096    
2097    
2098     # Loop over each entry in the search results list
2099     $ResultCount = 0;
2100     foreach $SearchResult ( @SearchResults ) {
2101    
2102     # Parse the headline, also get the first document item/type
2103     ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
2104    
2105     # Is this a query report
2106     if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
2107    
2108     # Retrieve the query report if it was not passed to us
2109     if ( !defined($QueryReport) ) {
2110     ($Status, $Text) = MPS::GetDocument($main::MPSSession, $Database, $DocumentID, $ItemName, $MimeType);
2111    
2112     if ( $Status ) {
2113     # Concatenate it to the query report text we have already got
2114     $FinalQueryReport .= $Text;
2115     }
2116     }
2117     }
2118     else {
2119     # Increment the result count
2120     $ResultCount++;
2121     }
2122     }
2123    
2124    
2125    
2126    
2127     # Finally, we get information we are going to need later on
2128    
2129     # Get the search string
2130     $SearchString = &sMakeSearchString(%Content);
2131     if ( defined($SearchString) ) {
2132     $SearchString =~ s/{.*?}//gs;
2133     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
2134     }
2135     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
2136    
2137     # Get the search string hash
2138     %SearchStringHash = &hGetSearchStringHash(%Content);
2139    
2140     # Do some very basic plural stemming
2141     foreach $Value ( keys (%SearchStringHash) ) {
2142     $Value =~ s/ies\Z/y/g;
2143     $Value =~ s/s\Z//g;
2144     $SearchStringHash{$Value} = $Value;
2145     }
2146    
2147    
2148    
2149     # Get the summary information
2150     if ( defined($main::RemoteUser) ) {
2151    
2152     $SummaryType = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SummaryType");
2153     $SummaryLength = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SummaryLength");
2154    
2155     if ( !(defined($SummaryLength) && ($SummaryLength ne "")) ) {
2156     $SummaryLength = $main::DefaultSummaryLength;
2157     }
2158     if ( !(defined($SummaryType) && ($SummaryType ne "")) ) {
2159     $SummaryType = $main::DefaultSummaryType;
2160     }
2161     }
2162     else {
2163     $SummaryType = $main::DefaultSummaryType;
2164     $SummaryLength = $main::DefaultSummaryLength;
2165     }
2166    
2167    
2168     # Print the header if needed
2169     if ( $Header ) {
2170    
2171     if ( $HTML ) {
2172     # Print the title and the start of the form
2173     printf("<H3>%s</H3>\n", defined($Title) ? $Title : "Rezultati pretra¾ivanja:");
2174    
2175     # Start the form
2176     print("<FORM ACTION=\"$ScriptName\" METHOD=POST>\n");
2177    
2178    
2179     # List the hidden fields
2180     %Value = &hParseURLIntoHashTable(&sMakeSearchURL(%Content));
2181     foreach $Value ( keys(%Value) ) {
2182     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
2183     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
2184     }
2185     }
2186    
2187    
2188     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2189    
2190     # Print the selector
2191     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");
2192    
2193     if ( $ResultCount > 0 ) {
2194    
2195     if ( defined($main::RemoteUser) ) {
2196     print("<SELECT NAME=\"Action\">\n");
2197    
2198     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
2199     if
2200     ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
2201     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
2202     }
2203     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
2204     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
2205     }
2206     print("<OPTION VALUE=\"GetSaveSearch\">Saèuvaj rezultate pretra¾ivanja\n");
2207     print("<OPTION VALUE=\"GetSaveFolder\">Saèuvaj odabrane rezultate u novi folder\n");
2208    
2209     # Get the document folder hash
2210     %QualifiedDocumentFolders = &hGetDocumentFolders;
2211    
2212     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
2213    
2214     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
2215    
2216     # Get the document folder file name and encode it
2217     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
2218     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
2219    
2220     print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry\">Dodaj odabrane rezultate u '$FolderName' folder\n");
2221     }
2222     print("</SELECT>\n");
2223     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
2224     }
2225     else {
2226     print("<SELECT NAME=\"Action\">\n");
2227     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
2228     if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
2229     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
2230     }
2231     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
2232     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
2233     }
2234     print("</SELECT>\n");
2235     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
2236     }
2237     }
2238     else {
2239     if ( defined($main::RemoteUser) ) {
2240     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSaveSearch\">\n");
2241     print("<INPUT TYPE=SUBMIT VALUE=\"Save this search\">\n");
2242     }
2243     }
2244    
2245     print("</TD></TR>\n");
2246     print("</TABLE>\n");
2247     }
2248     else {
2249     printf("%s\n", defined($Title) ? $Title : "Rezultati pretra¾ivanja:");
2250     }
2251    
2252    
2253     # Display the search string
2254     if ( $HTML ) {
2255     print("<CENTER><HR WIDTH=50%></CENTER>\n");
2256     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2257     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
2258     }
2259     else {
2260     print("--------------------------------------------------------------\n");
2261     print(" - Search for : $SearchString\n");
2262     }
2263    
2264    
2265     # Display the description
2266     if ( defined($SearchDescription) ) {
2267     if ( $HTML ) {
2268     $SearchDescription =~ s/\n/<BR>/g;
2269     $SearchDescription =~ s/\r/<BR>/g;
2270     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDescription </TD></TR>\n");
2271     }
2272     else {
2273     print(" - Description : $SearchDescription\n");
2274     }
2275     }
2276    
2277     # Display the date
2278     if ( defined($SearchDate) ) {
2279     if ( $HTML ) {
2280     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Run on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDate </TD></TR>\n");
2281     }
2282     else {
2283     print(" - Run on : $SearchDate\n");
2284     }
2285     }
2286    
2287     # Display the frequency
2288     if ( defined($SearchFrequency) ) {
2289     if ( $HTML ) {
2290     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Frequency: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchFrequency </TD></TR>\n");
2291     }
2292     else {
2293     print(" - Frequency : $SearchFrequency\n");
2294     }
2295     }
2296    
2297    
2298    
2299     # Get the databases from the search and list their descriptions
2300     if ( defined($Content{'Database'}) ) {
2301    
2302     # Initialize the temp list
2303     undef(@Values);
2304    
2305     # Loop over each database
2306     foreach $Database ( split(/\0/, $Content{'Database'}) ) {
2307     $Value = &lEncodeURLData($Database);
2308     if ( $HTML ) {
2309     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> ");
2310     }
2311     else {
2312     push @Values, sprintf("$main::DatabaseDescriptions{$Database} ");
2313     }
2314     }
2315    
2316     # Print the list if there are any entries in it
2317     if ( scalar(@Values) > 0 ) {
2318     if ( $HTML ) {
2319     printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n",
2320     (scalar(@Values) > 1) ? "s" : "", join(", ", @Values));
2321     }
2322     else {
2323     printf(" - Database%s : %s\n", (scalar(@Values) > 1) ? "s" : " ", join(", ", @Values));
2324     }
2325     }
2326     }
2327    
2328    
2329     # Display any feedback documents
2330     if ( defined($Content{'RfDocument'}) ) {
2331     if ( $HTML ) {
2332     print("<TR>\n");
2333     }
2334     &bDisplayDocuments("Feedback Document", $Content{'RfDocument'}, "RfDocument", 1, 1, $HTML);
2335     if ( $HTML ) {
2336     print("</TR>\n");
2337     }
2338     }
2339    
2340    
2341     if ( $HTML ) {
2342     printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Pronaðeno: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s rezultata (Maksimalni broj pode¹en na: $Content{'Max'} ) </TD></TR>\n",
2343     ($ResultCount > 0) ? $ResultCount : "no");
2344    
2345     print("</TABLE>\n");
2346     print("<CENTER><HR WIDTH=50%></CENTER>\n");
2347     }
2348     else {
2349     printf(" - Results : %s\n", ($ResultCount > 0) ? $ResultCount : "no");
2350     print("--------------------------------------------------------------\n\n");
2351     }
2352     }
2353    
2354    
2355     # Start the table
2356     if ( $HTML ) {
2357     print("<!-- searchResults -->\n");
2358     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2359    
2360     # Display a button to select all the documents
2361     if ( $ResultCount > 0 ) {
2362    
2363     if ( defined($Selector) && $Selector ) {
2364    
2365     $SelectorText = "";
2366    
2367     # Loop over each entry in the hits list
2368     foreach $SearchResult ( @SearchResults ) {
2369    
2370     # Parse the headline, also get the first document item/type
2371     ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
2372    
2373     # Skip query reports
2374     if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
2375     next;
2376     }
2377    
2378     $Value = "";
2379     $Value .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2380     $Value .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2381     $Value .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2382     $Value .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2383     $SelectorText .= (($SelectorText ne "") ? "|" : "") . substr($Value, 1);
2384     }
2385    
2386     $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
2387     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> $SelectorText </TD></TR>\n");
2388     }
2389     }
2390     }
2391    
2392    
2393 dpavlin 1.9 ### FIX:: ADD SORT HERE
2394 dpavlin 1.1 if ( $ResultCount > 0 ) {
2395    
2396     # Loop over each entry in the hits list
2397     foreach $SearchResult ( @SearchResults ) {
2398    
2399     # Parse the headline, also get the first document item/type
2400     ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
2401    
2402     # Skip query reports
2403     if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
2404     next;
2405     }
2406    
2407    
2408     # Put a separator between each entry
2409     if ( defined($Remainder) ) {
2410    
2411     if ( defined($RuleFlag) && ($RuleFlag) ) {
2412     if ( $HTML ) {
2413     print("<TR><TD COLSPAN=3><HR WIDTH=25%></TD></TR>\n");
2414     }
2415     else {
2416     print("--------------------------------------------------------------\n\n");
2417     }
2418     }
2419    
2420     $RuleFlag = 1;
2421     }
2422    
2423    
2424     # Get the summary if needed
2425     if ( defined($main::ConfigurationData{'allow-summary-displays'}) && ($main::ConfigurationData{'allow-summary-displays'} eq "yes") &&
2426     ($SummaryType ne "none") ) {
2427    
2428     ($Status, $Text) = MPS::GetDocument($main::MPSSession, $Database, $DocumentID, $ItemName, $MimeType);
2429    
2430     if ( $Status ) {
2431    
2432     # Then process for each summary type
2433     if ( $SummaryType eq "default" ) {
2434    
2435     $DatabaseSummaryFilterKey = "$main::DatabaseSummaryFilter:$Database:$ItemName:$MimeType";
2436    
2437     # Is a filter defined for this database summary filter key ?
2438     if ( defined($main::DatabaseFilters{$DatabaseSummaryFilterKey}) ) {
2439    
2440     # Pull in the package
2441     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Database"};
2442    
2443     # Filter the document
2444     $Value = $main::DatabaseFilters{$DatabaseSummaryFilterKey};
2445     $DatabaseSummaryFilterFunction = \&$Value;
2446     $Text = $DatabaseSummaryFilterFunction->($Database, $DocumentID, $ItemName, $MimeType, $Text);
2447    
2448     }
2449    
2450     # Truncate the summary to the length requested
2451     if ( defined ($Text) && ($Text ne "") ) {
2452    
2453     $CurrentSummaryLength = 0;
2454     $SummaryText = "";
2455    
2456     # Split the document text
2457     @Words = split(/(\W)/, $Text);
2458    
2459     # Loop over each word
2460     foreach $Offset ( 0..scalar(@Words) ) {
2461    
2462     # Skip undefined words
2463     if ( !defined($Words[$Offset]) ) {
2464     next;
2465     }
2466    
2467     # Increment and check the summary length
2468     if ( $Words[$Offset] ne " " ) {
2469    
2470     $CurrentSummaryLength++;
2471    
2472     if ( $CurrentSummaryLength > $SummaryLength ) {
2473     # Append a diaresys at the end and bail
2474     $SummaryText .= "...";
2475     last;
2476     }
2477     }
2478    
2479     # Append the current word to the end of the summary
2480     $SummaryText .= $Words[$Offset];
2481     }
2482     }
2483     else {
2484     $SummaryText = "(Document summary unavailable)";
2485     }
2486     }
2487     elsif ( $SummaryType eq "keyword" ) {
2488    
2489     # First clean up the text
2490     if ( index($Text, "\r\n") >= 0 ) {
2491     $Text =~ s/\r//gs;
2492     }
2493     elsif ( index($Text, "\r") >= 0 ) {
2494     $Text =~ s/\r/\n/gs;
2495     }
2496     if ( defined($main::HtmlMimeTypes{$MimeType}) ) {
2497     if ( ($Index = index($Text, "\n\n")) >= 0 ) {
2498     $Text = substr($Text, $Index);
2499     }
2500     $Text =~ s/&nbsp;//gs;
2501     $Text =~ s/<.*?>//gs;
2502     }
2503     $Text =~ s/\n/ /gs;
2504     $Text =~ s/\s+/ /gs;
2505     $Text = ucfirst($Text);
2506    
2507     # Initialize our variables
2508     $OldStart = -1;
2509     $OldEnd = -1;
2510    
2511     $Start = -1;
2512     $End = -1;
2513    
2514     $CurrentSummaryLength = 0;
2515    
2516     # Reset the offset pairs and offsets
2517     undef(@OffsetPairs);
2518     undef(%Offsets);
2519    
2520    
2521     # Split the document text
2522     @Words = split(/(\W)/, $Text);
2523    
2524    
2525     # Loop over each word, checking to see if it is in the search string hash table
2526     # and build the offset list as we go along, check with the previous offset to see
2527     # if there is an overlap
2528     foreach $Offset ( 0..scalar(@Words) ) {
2529    
2530     if ( !defined($Words[$Offset]) ) {
2531     next;
2532     }
2533    
2534     # Downcase the word
2535     $Word = lc($Words[$Offset]);
2536    
2537     # Very basic plural stemming
2538     $Word =~ s/ies\Z/y/g;
2539     $Word =~ s/s\Z//g;
2540    
2541     if ( !defined($SearchStringHash{$Word}) ) {
2542     next;
2543     }
2544    
2545     $Start = ($Offset < $main::SummaryKeywordSpan) ? 0 : $Offset - $main::SummaryKeywordSpan;
2546     $End = (($Offset + $main::SummaryKeywordSpan) > (scalar(@Words) - 1)) ? (scalar(@Words) - 1) : $Offset + $main::SummaryKeywordSpan;
2547    
2548     if ( @OffsetPairs ) {
2549     ($OldStart, $OldEnd) = split(/,/, $OffsetPairs[scalar(@OffsetPairs) - 1]);
2550     }
2551    
2552     if ( $OldEnd >= $Start ) {
2553     $OffsetPairs[scalar(@OffsetPairs) - 1] = "$OldStart,$End";
2554     }
2555     else {
2556     push @OffsetPairs, "$Start,$End";
2557     }
2558     $Offsets{$Offset} = $Offset;
2559     }
2560    
2561    
2562     # Now we rebuild the sentence from the words
2563     $SummaryText = "";
2564     foreach $OffsetPair ( @OffsetPairs ) {
2565    
2566     ($Start, $End) = split(/,/, $OffsetPair);
2567    
2568     if ( $Start > 0 ) {
2569     $SummaryText .= " ...";
2570     }
2571    
2572     foreach $Offset ( $Start..$End ) {
2573    
2574     if ( !defined($Words[$Offset]) ) {
2575     next;
2576     }
2577    
2578     if ( defined($Offsets{$Offset}) ) {
2579     $SummaryText .= "<FONT COLOR=\"GREEN\">$Words[$Offset]</FONT> ";
2580     }
2581     else {
2582     $SummaryText .= $Words[$Offset] . " ";
2583     }
2584    
2585     # Increment the summary length
2586     $CurrentSummaryLength++;
2587     }
2588    
2589     # Append a diaresys at the end
2590     if ( $End < scalar(@Words) ) {
2591     $SummaryText .= "... ";
2592     }
2593    
2594     # Bail if we have reached the max summary length
2595     if ( $CurrentSummaryLength > $SummaryLength ) {
2596     last;
2597     }
2598     }
2599     }
2600     }
2601     else {
2602     undef($SummaryText);
2603     }
2604     }
2605    
2606    
2607     # Decode the headline and strip the HTML
2608     $Headline = &lDecodeURLData($Headline);
2609     $Headline =~ s/&nbsp;//gs;
2610     $Headline =~ s/<.*?>//gs;
2611     $Headline =~ s/\s+/ /gs;
2612    
2613    
2614     # Create the selector text
2615     $SelectorText = "";
2616     if ( defined($Selector) && $Selector ) {
2617     $SelectorText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2618     $SelectorText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2619     $SelectorText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2620     $SelectorText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2621     $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"Document\" VALUE=\"" . substr($SelectorText, 1) . "\"> ";
2622     }
2623    
2624    
2625     # Put up the headline, the headline becomes the link to the document
2626    
2627     # Create the link, we use the URL if it is there,
2628     # otherwise we create a link from the document ID
2629     if ( defined($URL) && ($URL ne "") ) {
2630     $LinkText = $URL;
2631     }
2632     elsif ( defined($DocumentID) && ($DocumentID ne "") ) {
2633     $LinkText = "";
2634     $LinkText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2635     $LinkText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2636     $LinkText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2637     $LinkText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2638     $LinkText = "$ScriptName/GetDocument?" . substr($LinkText, 1);
2639     }
2640     else {
2641     $LinkText = "";
2642     }
2643    
2644     # Get the mime type name
2645     $MimeTypeName = (defined($main::MimeTypeNames{$MimeType})) ? $main::MimeTypeNames{$MimeType} : $MimeType;
2646    
2647     # Put up the headline and the score, this one links to the document
2648     if ( $HTML ) {
2649     print("<!-- resultItem -->\n");
2650 dpavlin 1.5 #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>");
2651 dpavlin 1.8 # decode some basic html from headline <b> <i>
2652     $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;
2653    
2654 dpavlin 1.5 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;");
2655     } else {
2656 dpavlin 1.1 printf("%3d $Headline ($main::DatabaseDescriptions{$Database})\n", $Score);
2657     }
2658    
2659 dpavlin 1.5 if (0) { ## don't display description
2660 dpavlin 1.1
2661     # Put up the summary
2662     if ( defined($SummaryText) && ($SummaryText ne "") ) {
2663     if ( $HTML ) {
2664     print(" <I> $SummaryText </I><BR>\n");
2665     }
2666     else {
2667     print(" $SummaryText\n");
2668     }
2669     }
2670    
2671    
2672     # Put up the mime type name
2673     if ( ! defined($Remainder) ) {
2674     if ( $HTML ) {
2675     print("Formatttt: $MimeTypeName, ");
2676 dpavlin 1.5
2677 dpavlin 1.1 }
2678     else {
2679     print(" Format: $MimeTypeName, ");
2680     }
2681     }
2682    
2683    
2684     # Put up the date if we got it
2685 dpavlin 1.5 if ( defined($Date) && ($Date ne "") ) {
2686 dpavlin 1.1 print("Date: $Date");
2687    
2688     # Put up the time if we got it
2689 dpavlin 1.5 if ( defined($Time) && ($Time ne "") ) {
2690 dpavlin 1.1 print(" $Time");
2691     }
2692    
2693     print(", ");
2694     }
2695    
2696    
2697     # Put up the document size, remember that there is only one
2698     # item name/mime type for this document if the remainder is undefined
2699     if ( ! defined($Remainder) ) {
2700     # Put up the length if it is defined
2701     if ( defined($Length) && ($Length ne "") ) {
2702     print("Size: $Length, ");
2703     }
2704    
2705     # Put up the link
2706     if ( $HTML ) {
2707     if ( defined($URL) && ($URL ne "") ) {
2708     $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
2709     print("<A HREF=\"$URL\"> $Value </A>\n");
2710     }
2711     }
2712     else {
2713     print(" URL: $LinkText\n");
2714     }
2715    
2716     # Finish off the entry
2717     if ( $HTML ) {
2718     print("</FONT></TD></TR>");
2719     print("<!-- /resultItem -->\n");
2720     }
2721     print("\n");
2722     }
2723     else {
2724    
2725     # There is a remainder, so there is more than one item name/mime type for this document,
2726     # the item names/mime types are listed as an un-numbered list
2727     if ( $HTML ) {
2728     print("<UL>");
2729     }
2730     print("\n");
2731    
2732     # Set the last item to an empty string, this is also used as a flag
2733     $LastItemName = "";
2734    
2735     # Loop while there are item names/mime types to be parsed
2736     do {
2737    
2738     # Get the next item name/mime type if the last item is set
2739     if ( $LastItemName ne "" ) {
2740     ($ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $Remainder, 5);
2741     }
2742    
2743    
2744     # If the item name has changed, so we close of the current list and start a new one
2745     if ( $ItemName ne $LastItemName ) {
2746     if ( $LastItemName ne "" ) {
2747     if ( $HTML ) {
2748     print("</UL>");
2749     }
2750     print("\n");
2751     }
2752     $Value = ucfirst($ItemName);
2753     if ( $HTML ) {
2754     print("<LI> $Value </LI>\n<UL>\n");
2755     }
2756     else {
2757     print("$Value\n");
2758     }
2759    
2760     # Set the last item name
2761     $LastItemName = $ItemName;
2762     }
2763    
2764    
2765     # Create the link, we use the URL if it is there,
2766     # otherwise we create a link from the document ID
2767     if ( defined($URL) && ($URL ne "") ) {
2768     $LinkText = $URL;
2769     }
2770     elsif ( defined($DocumentID) && ($DocumentID ne "") ) {
2771     $LinkText = "";
2772     $LinkText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2773     $LinkText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2774     $LinkText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2775     $LinkText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2776     $LinkText = "$ScriptName/GetDocument?" . substr($LinkText, 1);
2777     }
2778     else {
2779     $LinkText = "";
2780     }
2781    
2782    
2783     # Get the mime type name
2784     $MimeTypeName = defined($main::MimeTypeNames{$MimeType}) ? $main::MimeTypeNames{$MimeType} : $MimeType;
2785    
2786    
2787     # Put up the mime type, this one links to the document
2788     if ( $HTML ) {
2789     print("<LI><A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $MimeTypeName </A>");
2790     }
2791     else {
2792     print("$MimeTypeName ");
2793     }
2794    
2795     # Put up the length if it is defined
2796     if ( defined($Length) && ($Length ne "") ) {
2797     print("Size: $Length, ");
2798     }
2799    
2800     if ( $HTML ) {
2801     if ( defined($URL) && ($URL ne "") ) {
2802     $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
2803     print("<A HREF=\"$URL\"> $Value </A>\n");
2804     }
2805     print("</LI>\n");
2806     }
2807     else {
2808     print("URL: $LinkText\n");
2809     }
2810    
2811    
2812     } while ( defined($Remainder) ); # Keep looping while there are item names/mime types to process
2813    
2814     # Close off both un-numbered lists
2815     if ( $HTML ) {
2816     print("</UL></UL>");
2817     }
2818     print("\n");
2819    
2820 dpavlin 1.5 } #if
2821 dpavlin 1.1 # Finish off the entry
2822     if ( $HTML ) {
2823     print("</FONT></TD></TR>\n");
2824     print("<!-- /resultItem -->\n");
2825     }
2826     }
2827     }
2828     }
2829    
2830    
2831     # Print up the query report if it is defined
2832     if ( defined($FinalQueryReport) && ($FinalQueryReport ne "") ) {
2833    
2834     if ( $ResultCount > 0 ) {
2835     if ( $HTML ) {
2836     print("<TR><TD COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
2837     }
2838     else {
2839     print("--------------------------------------------------------------\n\n");
2840     }
2841     }
2842    
2843     if ( $HTML ) {
2844     print("<TR><TD COLSPAN=2></TD><TD ALIGN=LEFT VALIGN=TOP>\n");
2845     }
2846    
2847     $Value = $FinalQueryReport;
2848     if ( $HTML ) {
2849     $Value =~ s/\n/\<BR\>\n/g;
2850     }
2851    
2852     if ( $HTML ) {
2853     print("<SMALL>\n");
2854     }
2855    
2856     print("$Value");
2857    
2858     if ( $HTML ) {
2859     print("</SMALL>\n");
2860     print("</TD></TR>\n");
2861     }
2862     }
2863    
2864    
2865     if ( $HTML ) {
2866    
2867     # Close off the table
2868     print("<!-- /searchResults -->\n");
2869     print("</TABLE>\n");
2870    
2871     if ( $Header ) {
2872     # Close off the form
2873     print("</FORM>\n");
2874     }
2875     }
2876    
2877     # Return the status and the query report
2878     return (1, $FinalQueryReport);
2879    
2880     }
2881    
2882    
2883    
2884     #--------------------------------------------------------------------------
2885     #
2886     # Function: vGetSearch()
2887     #
2888     # Purpose: This function displays a search form to the user
2889     #
2890     # Called by:
2891     #
2892     # Parameters: void
2893     #
2894     # Global Variables: %main::ConfigurationData, %main::FormData, $main::RemoteUser
2895     #
2896     # Returns: void
2897     #
2898     sub vGetSearch {
2899    
2900     my (@ItemList, $ItemEntry, $Flag);
2901     my ($DatabaseName, $SelectedDatabases, $Year);
2902     my ($Value, %Value);
2903    
2904    
2905     # If we are getting the default search, we check to see if there is a
2906     # user name defined and if they chose to have a default search
2907     if ( $ENV{'PATH_INFO'} eq "/GetSearch" ) {
2908    
2909     if ( defined($main::RemoteUser) && defined($main::UserSettingsFilePath) ) {
2910    
2911     # Get the default search symbol
2912     $Value = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "DefaultSearch");
2913    
2914     # Set the default search
2915     if ( defined($Value) && ($Value eq "Simple") ) {
2916     $ENV{'PATH_INFO'} = "/GetSimpleSearch";
2917     }
2918     elsif ( defined($Value) && ($Value eq "Expanded") ) {
2919     $ENV{'PATH_INFO'} = "/GetExpandedSearch";
2920     }
2921     }
2922    
2923     # Override the default search if there is field from the expanded form defined
2924     foreach $Value ('FieldContent3', 'Past', 'Since', 'Before') {
2925     if ( defined($main::FormData{$Value}) ) {
2926     $ENV{'PATH_INFO'} = "/GetExpandedSearch";
2927     last;
2928     }
2929     }
2930     }
2931    
2932    
2933    
2934     # Make sure that we send the header
2935 dpavlin 1.16 $Value = ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ? "Slo¾eno pretra¾ivanje" : "Jednostavno pretra¾ivanje";
2936 dpavlin 1.6
2937 dpavlin 1.15 &vSendHTMLHeader($Value, $main::JavaScript_SetChecked);
2938 dpavlin 1.1
2939     undef(%Value);
2940     $Value{'GetSearch'} = "GetSearch";
2941     &vSendMenuBar(%Value);
2942     undef(%Value);
2943    
2944    
2945     # Print the header ($Value is reused from the header)
2946     print("<H3>$Value:</H3>\n");
2947    
2948    
2949     # We now have a list of valid databases, at least we think so,
2950     # we check that there is at least one and put up an error message if there are none
2951     if ( scalar(keys(%main::DatabaseDescriptions)) <= 0 ) {
2952     &vHandleError("Database Search", "Sorry, there were no valid databases available for searching");
2953     goto bailFromGetSearch;
2954     }
2955    
2956    
2957    
2958     # Start the search form table
2959     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2960    
2961     # Display the collapse and expand buttons
2962     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2>\n");
2963     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
2964    
2965     # List the hidden fields
2966     %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
2967     foreach $Value ( keys(%Value) ) {
2968     @ItemList = split(/\0/, $Value{$Value});
2969     foreach $ItemEntry ( @ItemList ) {
2970     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ItemEntry\">\n");
2971     }
2972     }
2973    
2974     if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
2975     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSimpleSearch\">\n");
2976 dpavlin 1.16 print("<INPUT SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'collapse'}\" BORDER=0 TYPE=IMAGE> Jednostavo pretra¾ivanje (kliknite na trokutiæ)\n");
2977 dpavlin 1.1 }
2978     else {
2979     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetExpandedSearch\">\n");
2980 dpavlin 1.16 print("<INPUT SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'expand'}\" BORDER=0 TYPE=IMAGE> Slo¾eno pretra¾ivanje (kliknite na trokutiæ)\n");
2981 dpavlin 1.1 }
2982     print("</FORM></TD>\n");
2983    
2984    
2985    
2986     # Send the start of the form and the buttons
2987     print("<TD ALIGN=RIGHT VALIGN=TOP>\n");
2988 dpavlin 1.6 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");
2989 dpavlin 1.1 print("</TD></TR>\n");
2990    
2991     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><BR></TD></TR>\n");
2992    
2993     # Send the standard fields
2994     $Value = defined($main::FormData{'Any'}) ? "VALUE='$main::FormData{'Any'}'" : "";
2995 dpavlin 1.17 print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Tra¾ene rijeèi neka budu u bilo kojem polju: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"Any\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
2996 dpavlin 1.1
2997    
2998     my $nr_fields = $main::NormalSearchDropdowns;
2999     my @SearchFieldNames = @main::NormalSearchFieldNames;
3000    
3001     if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
3002     $nr_fields = $main::AdvancedSearchDropdowns;
3003     @SearchFieldNames = @main::AdvancedSearchFieldNames;
3004     }
3005    
3006     for (my $field=1; $field<= $nr_fields; $field++) {
3007    
3008 dpavlin 1.17 print "<TR>";
3009 dpavlin 1.1 if ($field == 1 ) {
3010 dpavlin 1.17 print "<TD ALIGN=LEFT VALIGN=TOP ROWSPAN=$nr_fields>";
3011     print "Tra¾ene rijeèi neka budu u odabranom polju:";
3012     print "</td>";
3013 dpavlin 1.1 }
3014 dpavlin 1.17 print ("<TD ALIGN=RIGHT VALIGN=TOP>");
3015 dpavlin 1.1
3016     print ("<SELECT NAME=\"FieldName${field}\">");
3017     for (my $i=0; $i<=$#SearchFieldNames; $i++) {
3018     my $ItemEntry = $SearchFieldNames[$i];
3019 dpavlin 1.4 my $Selected = "";
3020     if ($main::FormData{"FieldName${field}"} && $main::FormData{"FieldName${field}"} eq $ItemEntry) {
3021     $Selected = "SELECTED";
3022     } elsif ($i == ($field - 1)) {
3023     $Selected = "SELECTED";
3024     }
3025    
3026 dpavlin 1.1 print("<OPTION VALUE=\"$ItemEntry\" $Selected> $main::SearchFieldDescriptions{$ItemEntry}\n");
3027     }
3028 dpavlin 1.4 my $Value = "";
3029     if (defined($main::FormData{"FieldContent${field}"})) {
3030     $Value = "VALUE='".$main::FormData{"FieldContent${field}"}."'";
3031     }
3032 dpavlin 1.17 print("</SELECT></TD><TD ALIGN=LEFT VALIGN=TOP><INPUT NAME=\"FieldContent${field}\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
3033 dpavlin 1.1 }
3034    
3035    
3036     # Send a pull-down which allows the user to select what to search for
3037     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");
3038     $Value = (defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "ADJ")) ? "SELECTED" : "";
3039     print("<OPTION VALUE=\"ADJ\"> Toènu frazu\n");
3040     $Value = ((defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "AND")) || !defined($main::FormData{'Operator'})) ? "SELECTED" : "";
3041     print("<OPTION VALUE=\"AND\" $Value> Sve rijeèi (AND)\n");
3042     $Value = (defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "OR")) ? "SELECTED" : "";
3043     print("<OPTION VALUE=\"OR\" $Value> Bilo koju rijeè (OR)\n");
3044     print("</SELECT> </TD></TR>\n");
3045    
3046    
3047     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3048    
3049    
3050    
3051     # Database selection
3052     if ( %main::DatabaseDescriptions ) {
3053    
3054 dpavlin 1.15 print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Odaberite bazu koju ¾elite pretra¾ivati:</TD></TR>
3055     <TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=4>
3056 dpavlin 1.5 ");
3057 dpavlin 1.1
3058     # Parse out the database names and put them into a
3059     # hash table, they should be separated with a '\0'
3060     undef(%Value);
3061     if ( defined($main::FormData{'Database'}) ) {
3062     @ItemList = split(/\0/, $main::FormData{'Database'});
3063     }
3064     else {
3065     $SelectedDatabases = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SelectedDatabases");
3066     if ( defined($SelectedDatabases) ) {
3067     @ItemList = split(",", $SelectedDatabases);
3068     }
3069     }
3070    
3071 dpavlin 1.7 &ShowDatabaseCheckBoxes(@ItemList);
3072 dpavlin 1.1
3073     print("</TD></TR>\n");
3074    
3075     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3076     }
3077    
3078    
3079     # Print out the RF documents
3080     if ( defined($main::FormData{'RfDocument'}) ) {
3081     print("<TR>\n");
3082     &bDisplayDocuments("Feedback Document", $main::FormData{'RfDocument'}, "RfDocument", 1, 1, 1);
3083     print("</TR>\n");
3084     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3085     }
3086    
3087    
3088     # Send complex search pull-downs
3089     if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
3090    
3091     if ($main::ConfigurationData{'show-past-date-list'} eq 'yes') {
3092    
3093     # Send the past date list
3094     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");
3095     $Value = (!defined($main::FormData{'Past'})) ? "SELECTED" : "";
3096     print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
3097     foreach $ItemEntry ( @main::PastDate ) {
3098     $Value = (defined($main::FormData{'Past'}) && ($main::FormData{'Past'} eq $ItemEntry)) ? "SELECTED" : "";
3099     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
3100     }
3101     print("</SELECT> </TD></TR>\n");
3102     }
3103    
3104    
3105     # Send the start date
3106     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");
3107     $Value = (!defined($main::FormData{'Since'})) ? "SELECTED" : "";
3108     print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
3109    
3110     $Year = (localtime)[5] + 1900;
3111    
3112     while ( $Year >= $main::ConfigurationData{'lowest-year'} ) {
3113     $Value = (defined($main::FormData{'Since'}) && ($main::FormData{'Since'} eq $Year)) ? "SELECTED" : "";
3114     print("<OPTION VALUE=\"$Year\" $Value> $Year \n");
3115     $Year--;
3116     }
3117     print("</SELECT> </TD></TR>\n");
3118    
3119    
3120     # Send the end date
3121     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");
3122     $Value = (!defined($main::FormData{'Before'})) ? "SELECTED" : "";
3123     print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
3124    
3125     $Year = (localtime)[5] + 1900;
3126    
3127     while ( $Year >= $main::ConfigurationData{'lowest-year'} ) {
3128     $Value = (defined($main::FormData{'Before'}) && ($main::FormData{'Before'} eq $Year)) ? "SELECTED" : "";
3129     print("<OPTION VALUE=\"$Year\" $Value> $Year \n");
3130     $Year--;
3131     }
3132     print("</SELECT> </TD></TR>\n");
3133    
3134     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3135     }
3136    
3137    
3138     # Send a pull-down which allows the user to select the max number of documents
3139     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Maksimalan broj rezultata pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Max\">\n");
3140    
3141     foreach $ItemEntry ( @main::MaxDocs ) {
3142     $Value = ((defined($main::FormData{'Max'}) && ($main::FormData{'Max'} eq $ItemEntry)) || (!defined($main::FormData{'Max'}) && ($ItemEntry eq $main::DefaultMaxDoc)) ) ? "SELECTED" : "";
3143     if ( ($ItemEntry >= 500) && $ENV{'PATH_INFO'} ne "/GetExpandedSearch" ) {
3144     next;
3145     }
3146     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
3147     }
3148    
3149     print("</SELECT> </TD></TR>\n");
3150    
3151    
3152     # Send a pull-down which allows the user to select the sort order
3153     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Sortiranje rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Order\">\n");
3154     # print("<OPTION VALUE=\"\"> Relevance\n");
3155     $Value = (defined($main::FormData{'Order'}) && ($main::FormData{'Order'} eq "SORT:DATE:DESC")) ? "SELECTED" : "";
3156     print("<OPTION VALUE=\"SORT:DATE:DESC\" $Value> Datum - najprije novije\n");
3157     $Value = (defined($main::FormData{'Order'}) && ($main::FormData{'Order'} eq "DATEASCSORT")) ? "SELECTED" : "";
3158     print("<OPTION VALUE=\"SORT:DATE:ASC\" $Value> Datum - najprije starije\n");
3159 dpavlin 1.9 ### FIX:: SORT
3160     # print("<OPTION VALUE=\"SORT:700+:DESC\"> autor\n");
3161     # print("<OPTION VALUE=\"SORT:200+:DESC\"> naslov\n");
3162 dpavlin 1.1 print("</SELECT> </TD></TR>\n");
3163    
3164    
3165     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3166     print("<TR><TD ALIGN=RIGHT COLSPAN=3><INPUT TYPE=SUBMIT VALUE=\"Pretra¾i bazu\"> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\"></TD></TR>\n");
3167    
3168     print("</FORM>\n");
3169     print("</TABLE>\n");
3170    
3171    
3172     # Bail from the search
3173     bailFromGetSearch:
3174    
3175     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3176     undef(%Value);
3177     $Value{'GetSearch'} = "GetSearch";
3178     &vSendMenuBar(%Value);
3179     undef(%Value);
3180    
3181     &vSendHTMLFooter;
3182    
3183     return;
3184    
3185     }
3186    
3187    
3188    
3189    
3190    
3191    
3192     #--------------------------------------------------------------------------
3193     #
3194     # Function: vGetSearchResults()
3195     #
3196     # Purpose: This function run the search and displays the results to the user
3197     #
3198     # Called by:
3199     #
3200     # Parameters: void
3201     #
3202     # Global Variables: %main::ConfigurationData, %main::FormData, $main::RemoteUser
3203     #
3204     # Returns: void
3205     #
3206     sub vGetSearchResults {
3207    
3208     my (%Databases, $Databases, $SearchString, $SearchAndRfDocumentURL, $RfText);
3209     my ($Status, $DocumentText, $SearchResults, $QueryReport, $ErrorNumber, $ErrorMessage);
3210     my ($DatabaseRelevanceFeedbackFilterKey, $DatabaseRelevanceFeedbackFilterFunction);
3211     my (@Values, %Value, $Value);
3212    
3213    
3214    
3215     # Check to see if there are any documents selected, if there are, they need
3216     # to be converted to RF documents before we put up the header, this is because
3217     # the header creates a search link from existing search fields, we also deduplicate
3218     # documents along the way
3219     if ( defined($main::FormData{'RfDocument'}) || defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) {
3220    
3221     # Undefine the hash table in preparation
3222     undef(%Value);
3223    
3224     # Make a hash table from the documents already selected for feedback
3225     if ( defined($main::FormData{'RfDocument'}) ) {
3226     foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
3227     $Value{$Value} = $Value;
3228     }
3229     }
3230    
3231     # Add document that were specifically selected
3232     if ( defined($main::FormData{'Document'}) ) {
3233     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
3234     $Value{$Value} = $Value;
3235     }
3236     }
3237     # Otherwise add documents that were selected by default
3238     elsif ( defined($main::FormData{'Documents'}) ) {
3239     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
3240     $Value{$Value} = $Value;
3241     }
3242     }
3243    
3244     # Assemble the new content
3245     $main::FormData{'RfDocument'} = join("\0", keys(%Value));
3246    
3247     # Delete the old content
3248     delete($main::FormData{'Document'});
3249     delete($main::FormData{'Documents'});
3250     }
3251    
3252    
3253     # Set the database names if needed
3254     if ( !defined($main::FormData{'Database'}) && defined($main::FormData{'RfDocument'}) ) {
3255    
3256     # Loop over each entry in the documents list
3257     foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
3258    
3259     # Parse out the document entry
3260     %Value = &hParseURLIntoHashTable($Value);
3261    
3262     # Add the database name to the hash table
3263     $Databases{$Value{'Database'}} = $Value{'Database'};
3264     }
3265    
3266     $main::FormData{'Database'} = join("\0", keys(%Databases));
3267     }
3268    
3269    
3270    
3271     # Make sure that we send the header
3272     &vSendHTMLHeader("Rezultati pretra¾ivanja", undef);
3273     undef(%Value);
3274     &vSendMenuBar(%Value);
3275    
3276    
3277     # Check that at least one database was selected
3278     if ( !defined($main::FormData{'Database'}) ) {
3279     print("<H3>Database Search:</H3>\n");
3280     print("<H3><CENTER>Sorry, no database(s) were selected for searching.</CENTER></H3>\n");
3281     print("<P>\n");
3282     print("There needs to be a least one database selected in order to perform the search.\n");
3283     print("Click <B>'back'</B> on your browser, select at least one database and try again.\n");
3284     goto bailFromGetSearchResults;
3285     }
3286    
3287    
3288    
3289     # Extract the search information
3290     foreach $Value ( 1..100 ) {
3291    
3292     my ($FieldName) = "FieldName" . $Value;
3293     my ($FieldContent) = "FieldContent" . $Value;
3294    
3295     if ( defined($main::FormData{$FieldName}) ) {
3296     if ( defined($main::FormData{$FieldContent}) && ($main::FormData{$FieldContent} ne "") ) {
3297     $main::FormData{$main::FormData{$FieldName}} = $main::FormData{$FieldContent};
3298     }
3299     }
3300     }
3301    
3302    
3303    
3304     # Set the local database names
3305     if ( defined($main::FormData{'Database'}) ) {
3306     $Databases = $main::FormData{'Database'};
3307     }
3308    
3309    
3310     # Convert all the '\0' to ','
3311     $Databases =~ tr/\0/,/;
3312    
3313    
3314     # Add the max doc restriction
3315     if ( !defined($main::FormData{'Max'}) ) {
3316     $main::FormData{'Max'} = $main::DefaultMaxDoc;
3317     }
3318    
3319    
3320     # Generate the search string
3321     $SearchString = &sMakeSearchString(%main::FormData);
3322    
3323     # Retrieve the relevance feedback documents
3324     if ( defined($main::FormData{'RfDocument'}) ) {
3325    
3326     $RfText = "";
3327    
3328     # Loop over each entry in the documents list
3329     foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
3330    
3331     # Parse out the document entry
3332     %Value = &hParseURLIntoHashTable($Value);
3333    
3334     # Check this document can be used for relevance feedback
3335     if ( !defined($main::RFMimeTypes{$Value{'MimeType'}}) ) {
3336     next;
3337     }
3338    
3339     # Get the document
3340     ($Status, $DocumentText) = MPS::GetDocument($main::MPSSession, $Value{'Database'}, $Value{'DocumentID'}, $Value{'ItemName'}, $Value{'MimeType'});
3341    
3342     if ( $Status ) {
3343    
3344     $DatabaseRelevanceFeedbackFilterKey = "$main::DatabaseRelevanceFeedbackFilter:$Value{'Database'}:$Value{'ItemName'}:$Value{'MimeType'}";
3345    
3346     # Is a filter defined for this database relevance feedback filter key ?
3347     if ( defined($main::DatabaseFilters{$DatabaseRelevanceFeedbackFilterKey}) ) {
3348    
3349     # Pull in the package
3350     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Value{'Database'}"};
3351    
3352     # Filter the document
3353     $Value = $main::DatabaseFilters{$DatabaseRelevanceFeedbackFilterKey};
3354     $DatabaseRelevanceFeedbackFilterFunction = \&$Value;
3355     $DocumentText = $DatabaseRelevanceFeedbackFilterFunction->($Value{'Database'}, $Value{'DocumentID'}, $Value{'ItemName'}, $Value{'MimeType'}, $DocumentText);
3356    
3357     }
3358     else {
3359    
3360     # Strip the HTML from the text (this is only really useful on HTML documents)
3361     if ( defined($main::HtmlMimeTypes{$Value{'MimeType'}}) ) {
3362     $DocumentText =~ s/&nbsp;//gs;
3363     $DocumentText =~ s/<.*?>//gs;
3364     }
3365     }
3366    
3367     $RfText .= $DocumentText . " ";
3368     }
3369     }
3370     }
3371    
3372    
3373     # Run the search
3374     ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Databases, $SearchString, $RfText, 0, $main::FormData{'Max'} - 1, $main::ConfigurationData{'max-score'});
3375    
3376     if ( $Status ) {
3377    
3378     # Display the search results and get the query report text
3379     ($Status, $QueryReport) = &bsDisplaySearchResults("Rezultati pretra¾ivanja:", undef, undef, undef, $SearchResults, undef, $ENV{'SCRIPT_NAME'}, 1, 1, 1, %main::FormData);
3380    
3381     # Save the search history
3382     if ( defined($main::RemoteUser) ) {
3383    
3384     # Generate the search string
3385     $SearchAndRfDocumentURL = &sMakeSearchAndRfDocumentURL(%main::FormData);
3386    
3387     # Save the search history
3388     &iSaveSearchHistory(undef, $SearchAndRfDocumentURL, $SearchResults, $QueryReport);
3389    
3390     # Purge the search history files
3391     &vPurgeSearchHistory;
3392     }
3393     }
3394     else {
3395     ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
3396     &vHandleError("Database Search", "Sorry, failed to search the database(s)");
3397     print("The following error message was reported: <BR>\n");
3398     print("Error Message: $ErrorMessage <BR>\n");
3399     print("Error Number: $ErrorNumber <BR>\n");
3400     goto bailFromGetSearchResults;
3401     }
3402    
3403    
3404     # Bail from the search
3405     bailFromGetSearchResults:
3406    
3407     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3408     undef(%Value);
3409     &vSendMenuBar(%Value);
3410    
3411     &vSendHTMLFooter;
3412    
3413     return;
3414    
3415     }
3416    
3417    
3418    
3419    
3420    
3421    
3422     #--------------------------------------------------------------------------
3423     #
3424     # Function: vGetDatabaseInfo()
3425     #
3426     # Purpose: This function allows the user to get some database information
3427     # such as the description, the contents and the time period spanned
3428     # by the content.
3429     #
3430     # Called by:
3431     #
3432     # Parameters: void
3433     #
3434     # Global Variables: %main::ConfigurationData, %main::FormData
3435     #
3436     # Returns: void
3437     #
3438     sub vGetDatabaseInfo {
3439    
3440     my ($DatabaseDescription, $DatabaseLanguage, $DatabaseTokenizer, $DocumentCount, $TotalWordCount, $UniqueWordCount, $StopWordCount, $AccessControl, $UpdateFrequency, $LastUpdateDate, $LastUpdateTime, $CaseSensitive);
3441     my ($FieldInformation, $FieldName, $FieldDescription);
3442     my ($Status, $Text, $Time, $Title);
3443     my ($ErrorNumber, $ErrorMessage);
3444     my ($Value, %Value);
3445    
3446    
3447    
3448     # Check we that we got a database name
3449     if ( !defined($main::FormData{'Database'}) ) {
3450     &vHandleError("Database information", "Sorry, the database content description could not be obtained");
3451     goto bailFromGetDatabaseInfo;
3452     }
3453    
3454    
3455     # Make sure that we send the header
3456     $Title = "Database Information: " . (defined($main::DatabaseDescriptions{$main::FormData{'Database'}})
3457     ? $main::DatabaseDescriptions{$main::FormData{'Database'}} : "");
3458     &vSendHTMLHeader($Title, undef);
3459     undef(%Value);
3460     &vSendMenuBar(%Value);
3461    
3462    
3463     # Get the database information
3464     ($Status, $Text) = MPS::GetDatabaseInfo($main::MPSSession, $main::FormData{'Database'});
3465    
3466     if ( $Status ) {
3467    
3468     # Display the database information
3469     print("<H3>Database information:</H3>\n");
3470    
3471     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
3472    
3473    
3474     # Send the database description
3475     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");
3476     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3477    
3478     # Truncate the line
3479     chop ($Text);
3480    
3481     # Parse the database information
3482     ($DatabaseDescription, $DatabaseLanguage, $DatabaseTokenizer, $DocumentCount, $TotalWordCount, $UniqueWordCount, $StopWordCount, $AccessControl, $UpdateFrequency, $LastUpdateDate, $LastUpdateTime, $CaseSensitive) = split(/\t/, $Text);
3483    
3484     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");
3485     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Total number of words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $TotalWordCount </TD></TR>\n");
3486     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Number of unique words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $UniqueWordCount </TD></TR>\n");
3487     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Number of stop words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $StopWordCount </TD></TR>\n");
3488    
3489     # Get the time of last update of the data directory
3490     # $Time = (stat("$main::ConfigurationData{'data-directory'}/$main::FormData{'Database'}/"))[9];
3491     # $Value = &sGetPrintableDateFromTime($Time);
3492     # print("<TR><TD ALIGN=LEFT VALIGN=TOP> Data last updated on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
3493    
3494     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Index last updated on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $LastUpdateDate ($LastUpdateTime) </TD></TR>\n");
3495    
3496     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3497    
3498     # Get the database field information
3499     ($Status, $Text) = MPS::GetDatabaseFieldInfo($main::MPSSession, $main::FormData{'Database'});
3500    
3501     if ( $Status ) {
3502     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");
3503    
3504     foreach $FieldInformation ( split(/\n/, $Text) ) {
3505     ($FieldName, $FieldDescription, $Value) = split(/\t/, $FieldInformation, 3);
3506     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> $FieldName </TD> <TD ALIGN=LEFT VALIGN=TOP> $FieldDescription </TD></TR>\n");
3507     }
3508     }
3509    
3510     print("</TABLE>\n");
3511    
3512     }
3513     else {
3514     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Text, 2);
3515     &vHandleError("Database information", "Sorry, failed to get the database information");
3516     print("The following error message was reported: <BR>\n");
3517     print("Error Message: $ErrorMessage <BR>\n");
3518     print("Error Number: $ErrorNumber <BR>\n");
3519     goto bailFromGetDatabaseInfo;
3520     }
3521    
3522    
3523    
3524     # Bail from the database info
3525     bailFromGetDatabaseInfo:
3526    
3527     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3528     undef(%Value);
3529     &vSendMenuBar(%Value);
3530    
3531     &vSendHTMLFooter;
3532    
3533     return;
3534    
3535     }
3536    
3537    
3538    
3539    
3540    
3541    
3542     #--------------------------------------------------------------------------
3543     #
3544     # Function: vGetDocument()
3545     #
3546     # Purpose: This function get a document from the database.
3547     #
3548     # Called by:
3549     #
3550     # Parameters: void
3551     #
3552     # Global Variables: %main::ConfigurationData, %main::FormData,
3553     # $main::FooterSent
3554     #
3555     # Returns: void
3556     #
3557     sub vGetDocument {
3558    
3559     my (@DocumentList, %Document, $Document, $TextDocumentFlag);
3560     my ($Status, $Data, $ErrorNumber, $ErrorMessage);
3561     my (%QualifiedDocumentFolders, $QualifiedDocumentFolders, $FolderName, $DocumentFolderEntry);
3562     my ($DatabaseDocumentFilterFunction, $DatabaseDocumentFilterKey);
3563     my ($SelectorText, $FilteredData, $SimilarDocuments, $SearchResults);
3564     my (%Value, $Value);
3565    
3566    
3567    
3568     # Assemble the documents selected into a list do that we keep their order
3569     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) || defined($main::FormData{'DocumentID'}) ) {
3570    
3571     # Undefine the hash table in preparation
3572     undef(%Value);
3573    
3574     # Add document that were specifically selected
3575     if ( defined($main::FormData{'Document'}) ) {
3576     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
3577     if ( !defined($Value{$Value}) ) {
3578     push @DocumentList, $Value;
3579     $Value{$Value} = $Value;
3580     }
3581     }
3582     }
3583     # Otherwise add documents that were selected by default
3584     elsif ( defined($main::FormData{'Documents'}) ) {
3585     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
3586     if ( !defined($Value{$Value}) ) {
3587     push @DocumentList, $Value;
3588     $Value{$Value} = $Value;
3589     }
3590     }
3591     }
3592    
3593     # Add document from the URL
3594     if ( defined($main::FormData{'DocumentID'}) ) {
3595     $Value = "";
3596     $Value .= (defined($main::FormData{'Database'}) && ($main::FormData{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($main::FormData{'Database'}) : "";
3597     $Value .= (defined($main::FormData{'DocumentID'}) && ($main::FormData{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($main::FormData{'DocumentID'}) : "";
3598     $Value .= (defined($main::FormData{'ItemName'}) && ($main::FormData{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($main::FormData{'ItemName'}) : "";
3599     $Value .= (defined($main::FormData{'MimeType'}) && ($main::FormData{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($main::FormData{'MimeType'}) : "";
3600     if ( !defined($Value{$Value}) ) {
3601     push @DocumentList, $Value;
3602     $Value{$Value} = $Value;
3603     }
3604     }
3605     }
3606    
3607    
3608    
3609     # Catch no document selection
3610     if ( !@DocumentList || (scalar(@DocumentList) == 0) ) {
3611    
3612     # Make sure that we send the header
3613     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3614     &vSendHTMLHeader("Similar Documents", undef);
3615     }
3616     else {
3617     &vSendHTMLHeader("Documents", undef);
3618     }
3619     undef(%Value);
3620     &vSendMenuBar(%Value);
3621    
3622     print("<H3>Document retrieval:</H3>\n");
3623     print("<H3><CENTER>Sorry, no document(s) were selected for retrieval.</CENTER></H3>\n");
3624     print("<P>\n");
3625     print("There needs to be a least one document selected in order to perform the retrieval.\n");
3626     print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
3627     goto bailFromGetDocument;
3628     }
3629    
3630    
3631    
3632     # Set the text document flag
3633     $TextDocumentFlag = 0;
3634    
3635     # Check the documents for text based documents
3636     foreach $Document ( @DocumentList ) {
3637    
3638     # Parse out the document entry
3639     %Document = &hParseURLIntoHashTable($Document);
3640    
3641     # Set the text flag if there are any text documents in the list
3642     if ( $Document{'MimeType'} =~ /^text\// ) {
3643     $TextDocumentFlag = 1;
3644     }
3645     }
3646    
3647    
3648    
3649     # If there were no text documents in our list, we display the first document in the
3650     # list, this is to handle cases where got one or more non-text documents (such as
3651     # images, pdf files, etc)
3652     if ( ! $TextDocumentFlag ) {
3653    
3654     %Document = &hParseURLIntoHashTable($DocumentList[0]);
3655    
3656     # Get the document
3657     ($Status, $Data) = MPS::GetDocument($main::MPSSession, $Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'});
3658    
3659     if ( !$Status ) {
3660    
3661     # Make sure that we send the header
3662     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3663     &vSendHTMLHeader("Similar Documents", undef);
3664     }
3665     else {
3666     &vSendHTMLHeader("Documents", undef);
3667     }
3668     undef(%Value);
3669     &vSendMenuBar(%Value);
3670    
3671     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Data, 2);
3672     # The database document could not be gotten, so we inform the user of the fact
3673     &vHandleError("Document retrieval", "Sorry, the database document could not be obtained");
3674     print("The following error message was reported: <BR>\n");
3675     print("Error Message: $ErrorMessage <BR>\n");
3676     print("Error Number: $ErrorNumber <BR>\n");
3677     goto bailFromGetDocument;
3678     }
3679    
3680     # Send the content type
3681     print("Content-type: $Document{'MimeType'}\n\n");
3682    
3683     # Send the document
3684     print("$Data");
3685    
3686     return;
3687     }
3688    
3689    
3690    
3691     # Make sure that we send the header
3692     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3693     &vSendHTMLHeader("Similar Documents", undef);
3694     }
3695     else {
3696     &vSendHTMLHeader("Documents", undef);
3697     }
3698     undef(%Value);
3699     &vSendMenuBar(%Value);
3700    
3701    
3702    
3703     # Print the header
3704     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3705     print("<H3>Similar Documents:</H3>\n");
3706     }
3707     else {
3708     print("<H3>Dokumenti:</H3>\n");
3709     }
3710    
3711    
3712     # Start the form
3713     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
3714    
3715     # Send the pull-down
3716     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
3717     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");
3718    
3719     if ( defined($main::RemoteUser) ) {
3720     print("<SELECT NAME=\"Action\">\n");
3721     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3722     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
3723     }
3724     if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
3725     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
3726     }
3727     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
3728     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
3729     }
3730     print("<OPTION VALUE=\"GetSaveFolder\">Save selected documents to a new document folder\n");
3731    
3732     # Get the document folder hash
3733     %QualifiedDocumentFolders = &hGetDocumentFolders;
3734    
3735     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
3736    
3737     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
3738    
3739     # Get the document folder file name and encode it
3740     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
3741     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
3742    
3743     print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry\">Add selected documents to the '$FolderName' document folder\n");
3744     }
3745    
3746     print("</SELECT>\n");
3747     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
3748     }
3749     else {
3750     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
3751     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSearchResults\">\n");
3752     print("<INPUT TYPE=SUBMIT VALUE=\"Run search with documents as relevance feedback\">\n");
3753     }
3754     }
3755    
3756     print("</TD></TR>\n");
3757     print("</TABLE>\n");
3758    
3759    
3760     # Display the documents
3761    
3762     print("<TABLE BORDER=0 CELLPADDING=3 CELLSPACING=0 WIDTH=100%>\n");
3763    
3764    
3765     # Display the selector for all the documents
3766     $SelectorText = "";
3767    
3768     foreach $Document ( @DocumentList ) {
3769    
3770     # Parse out the document entry
3771     %Document = &hParseURLIntoHashTable($Document);
3772    
3773     # Skip non-text documents
3774     if ( !($Document{'MimeType'} =~ /^text\//) ) {
3775     next;
3776     }
3777    
3778     $Value = "";
3779     $Value .= (defined($Document{'Database'}) && ($Document{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Document{'Database'}) : "";
3780     $Value .= (defined($Document{'DocumentID'}) && ($Document{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Document{'DocumentID'}) : "";
3781     $Value .= (defined($Document{'ItemName'}) && ($Document{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($Document{'ItemName'}) : "";
3782     $Value .= (defined($Document{'MimeType'}) && ($Document{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($Document{'MimeType'}) : "";
3783     $SelectorText .= (($SelectorText ne "") ? "|" : "") . substr($Value, 1);
3784     }
3785    
3786     $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
3787     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> $SelectorText </TD></TR>\n");
3788    
3789    
3790    
3791     # Get the similar documents value
3792     if ( defined($main::RemoteUser) ) {
3793     $SimilarDocuments = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SimilarDocuments");
3794     }
3795     else {
3796     $SimilarDocuments = $main::DefaultSimilarDocument;
3797     }
3798    
3799    
3800    
3801     foreach $Document ( @DocumentList ) {
3802    
3803     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3> <HR WIDTH=50%> </TD></TR>\n");
3804    
3805    
3806     # Parse out the document entry
3807     %Document = &hParseURLIntoHashTable($Document);
3808    
3809     # Skip non-text documents
3810     if ( !($Document{'MimeType'} =~ /^text\//) ) {
3811     next;
3812     }
3813    
3814    
3815     # Get the document
3816     ($Status, $Data) = MPS::GetDocument($main::MPSSession, $Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'});
3817    
3818     if ( !$Status ) {
3819     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Data, 2);
3820     # The database document could not be gotten, so we inform the user of the fact
3821     &vHandleError("Document retrieval", "Sorry, the database document could not be obtained");
3822     print("The following error message was reported: <BR>\n");
3823     print("Error Message: $ErrorMessage <BR>\n");
3824     print("Error Number: $ErrorNumber <BR>\n");
3825     goto bailFromGetDocument;
3826     }
3827    
3828    
3829     # Create the database document filter key
3830     $DatabaseDocumentFilterKey = "$main::DatabaseDocumentFilter:$Document{'Database'}:$Document{'ItemName'}:$Document{'MimeType'}";
3831    
3832     # Is a filter defined for this database document filter key ?
3833     if ( defined($main::DatabaseFilters{$DatabaseDocumentFilterKey}) ) {
3834    
3835     # Pull in the package
3836     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Document{'Database'}"};
3837    
3838     # Filter the document
3839     $Value = $main::DatabaseFilters{$DatabaseDocumentFilterKey};
3840     $DatabaseDocumentFilterFunction = \&$Value;
3841     $FilteredData = $DatabaseDocumentFilterFunction->($Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'}, $Data);
3842     } else {
3843     # use default filter key
3844    
3845     # Pull in the package
3846     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:default"};
3847    
3848     # Filter the document
3849     $Value = $main::DatabaseFilters{"$main::DatabaseDocumentFilter:default:$Document{'ItemName'}:$Document{'MimeType'}"};
3850     $DatabaseDocumentFilterFunction = \&$Value;
3851     $FilteredData = $DatabaseDocumentFilterFunction->($Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'}, $Data);
3852     }
3853    
3854    
3855    
3856     # Create the document selector button text
3857     $SelectorText = "";
3858     $SelectorText .= (defined($Document{'Database'}) && ($Document{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Document{'Database'}) : "";
3859     $SelectorText .= (defined($Document{'DocumentID'}) && ($Document{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Document{'DocumentID'}) : "";
3860     $SelectorText .= (defined($Document{'ItemName'}) && ($Document{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($Document{'ItemName'}) : "";
3861     $SelectorText .= (defined($Document{'MimeType'}) && ($Document{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($Document{'MimeType'}) : "";
3862     $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"Document\" VALUE=\"" . substr($SelectorText, 1) . "\"> ";
3863    
3864    
3865     # Send the document text
3866     print("<TR><TD ALIGN=LEFT VALIGN=TOP> $SelectorText </TD> <TD ALIGN=LEFT VALIGN=TOP>$FilteredData</TD></TR>");
3867     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3868    
3869     # Get the similar documents if needed
3870     if ( defined($main::ConfigurationData{'allow-similiar-search'}) && ($main::ConfigurationData{'allow-similiar-search'} eq "yes") &&
3871     defined($SimilarDocuments) ) {
3872    
3873     # Run the search, discard the query report
3874     ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Document{'Database'}, "{NOREPORT}", $Data, 0, $SimilarDocuments - 1, $main::ConfigurationData{'max-score'});
3875    
3876     if ( $Status ) {
3877    
3878     # Display the search result
3879     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3> <HR WIDTH=25%> </TD></TR>\n");
3880     print("<TR><TD ALIGN=LEFT VALIGN=TOP></TD> <TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> \n");
3881     print("<B>Similar Documents:</B>\n");
3882     ($Status, undef) = &bsDisplaySearchResults("Similar Documents:", undef, undef, undef, $SearchResults, undef, $ENV{'SCRIPT_NAME'}, 0, 1, 1, %main::FormData);
3883     print("</TD></TR>\n");
3884     }
3885     else {
3886     ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
3887     &vHandleError("Database Search", "Sorry, failed to search the database(s)");
3888     print("The following error message was reported: <BR>\n");
3889     print("Error Message: $ErrorMessage <BR>\n");
3890     print("Error Number: $ErrorNumber <BR>\n");
3891     goto bailFromGetDocument;
3892     }
3893     }
3894     }
3895     }
3896    
3897    
3898     # Close off the form
3899     print("</FORM>\n");
3900    
3901     # Close off the table
3902     print("</TABLE>\n");
3903    
3904    
3905     # Bail from getting the document
3906     bailFromGetDocument:
3907    
3908     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3909     undef(%Value);
3910     &vSendMenuBar(%Value);
3911    
3912     &vSendHTMLFooter;
3913    
3914     return;
3915    
3916     }
3917    
3918    
3919    
3920    
3921    
3922    
3923     #--------------------------------------------------------------------------
3924     #
3925     # Function: vGetUserSettings()
3926     #
3927     # Purpose: This function displays a user settings form to the user
3928     #
3929     # Called by:
3930     #
3931     # Parameters: void
3932     #
3933     # Global Variables: %main::ConfigurationData, %main::FormData,
3934     # $main::UserSettingsFilePath, $main::RemoteUser,
3935     #
3936     # Returns: void
3937     #
3938     sub vGetUserSettings {
3939    
3940     my ($UserName, $SearchHistory, $DefaultSearch, $SelectedDatabases, $EmailAddress, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SummaryType, $SummaryLength, $SimilarDocuments);
3941     my ($SearchHistoryCount, $HeaderName);
3942     my ($DatabaseName, @ItemList, $ItemEntry, $Flag);
3943     my ($Value, %Value);
3944    
3945    
3946     # Return an error if the remote user name/account directory is not defined
3947     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
3948     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
3949     &vSendHTMLFooter;
3950     return;
3951     }
3952    
3953    
3954    
3955     # Make sure that we send the header
3956 dpavlin 1.15 &vSendHTMLHeader("My Settings", $main::JavaScript_SetChecked);
3957 dpavlin 1.1 undef(%Value);
3958     $Value{'GetUserSettings'} = "GetUserSettings";
3959     &vSendMenuBar(%Value);
3960     undef(%Value);
3961    
3962    
3963    
3964     # Get information from the XML saved search file
3965     ($HeaderName, %Value) = &shGetHashFromXMLFile($main::UserSettingsFilePath);
3966    
3967     # Check the header if it is defines, delete the file if it is not valid,
3968     # else set the variables from the hash table contents
3969     if ( defined($HeaderName) ) {
3970     if ( $HeaderName ne "UserSettings" ) {
3971     unlink($main::UserSettingsFilePath);
3972     }
3973     else {
3974     $UserName = $Value{'UserName'};
3975     $SearchHistory = $Value{'SearchHistory'};
3976     $DefaultSearch = $Value{'DefaultSearch'};
3977     $SelectedDatabases = $Value{'SelectedDatabases'};
3978     $EmailAddress = $Value{'EmailAddress'};
3979     $SearchFrequency = $Value{'SearchFrequency'};
3980     $DeliveryFormat = $Value{'DeliveryFormat'};
3981     $DeliveryMethod = $Value{'DeliveryMethod'};
3982     $SummaryType = $Value{'SummaryType'};
3983     $SummaryLength = $Value{'SummaryLength'};
3984     $SimilarDocuments = $Value{'SimilarDocuments'};
3985     }
3986     }
3987    
3988    
3989     # Give the user a form to fill out
3990    
3991     print("<H3> Postavke: </H3>\n");
3992    
3993     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
3994 dpavlin 1.15 print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetUserSettings\" NAME=\"Search\" METHOD=POST>\n");
3995 dpavlin 1.1
3996     # Send the buttons
3997     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=2> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\"> <INPUT TYPE=SUBMIT VALUE=\"Saèuvaj postavke\"> </TD></TR>\n");
3998    
3999    
4000    
4001     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4002    
4003     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Informacije o korisniku: </B> </TR>\n");
4004    
4005     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Login: </TD><TD ALIGN=LEFT VALIGN=TOP> $ENV{'REMOTE_USER'} </TD></TR>\n");
4006    
4007     $Value = (defined($UserName)) ? "VALUE=\"$UserName\"" : "";
4008     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");
4009    
4010     # Are regular searches enabled?
4011     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4012    
4013     # Get the email address
4014     $Value = (defined($EmailAddress)) ? "VALUE=\"$EmailAddress\"" : "";
4015     print("<TR><TD ALIGN=LEFT VALIGN=TOP> E-mail adresa:");
4016     if ( !defined($EmailAddress) && defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4017     print(" (*) ");
4018     }
4019     print(": </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"EmailAddress\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
4020    
4021     if ( !defined($EmailAddress) && defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4022     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");
4023     }
4024     }
4025    
4026    
4027     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4028    
4029     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Search Preferences: </B> </TD></TR>\n");
4030    
4031     # Send a pull-down which allows the user to select which search form to default to
4032     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Forma za pretra¾ivanje: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DefaultSearch\">\n");
4033     $Value = (defined($DefaultSearch) && ($DefaultSearch eq "Simple")) ? "SELECTED" : "";
4034     print("<OPTION VALUE=\"Simple\" $Value> Jednostavna forma za pretra¾ivanje\n");
4035     $Value = (defined($DefaultSearch) && ($DefaultSearch eq "Expanded")) ? "SELECTED" : "";
4036     print("<OPTION VALUE=\"Expanded\" $Value>Forma za pretra¾ivanje s vi¹e kriterija\n");
4037     print("</SELECT> </TD></TR>\n");
4038    
4039     # Send a pull-down which allows the user to select how many previous searches to store
4040     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");
4041    
4042     for ( $SearchHistoryCount = 5; $SearchHistoryCount <= 20; $SearchHistoryCount += 5 ) {
4043     $Value = (defined($SearchHistory) && ($SearchHistory == $SearchHistoryCount)) ? "SELECTED" : "";
4044     print("<OPTION VALUE=\"$SearchHistoryCount\" $Value> $SearchHistoryCount \n");
4045     }
4046     print("</SELECT> </TD></TR>\n");
4047    
4048    
4049     # Database selection preferences
4050     if ( %main::DatabaseDescriptions ) {
4051    
4052     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4053    
4054     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Odabrane baze: </B> </TD></TR>\n");
4055    
4056 dpavlin 1.15 print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Oznaèite baze koje uvijek ¾elite pretra¾ivati:</TD></TR><TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2>\n");
4057 dpavlin 1.1
4058     # Parse out the database names and put them into a
4059     # hash table, they should be separated with a '\n'
4060     if ( defined($SelectedDatabases) && ($SelectedDatabases ne "") ) {
4061     @ItemList = split(",", $SelectedDatabases);
4062     }
4063 dpavlin 1.15
4064 dpavlin 1.7 &ShowDatabaseCheckBoxes(@ItemList);
4065    
4066 dpavlin 1.1 print("</TD></TR>\n");
4067     }
4068    
4069    
4070    
4071     # Send a pull-down which allows the user to select whether to display summaries or not, and how long we want them
4072     if ( defined($main::ConfigurationData{'allow-summary-displays'}) && ($main::ConfigurationData{'allow-summary-displays'} eq "yes") ) {
4073    
4074     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4075    
4076     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Document Summary Preferences: </B> </TD></TR>\n");
4077    
4078     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Document summary type: </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SummaryType\">\n");
4079     foreach $ItemEntry ( keys (%main::SummaryTypes) ) {
4080     $Value = (defined($SummaryType) && ($SummaryType eq $ItemEntry)) ? "SELECTED" : "";
4081     print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::SummaryTypes{$ItemEntry}\n");
4082     }
4083     print("</SELECT></TD></TR>\n");
4084    
4085     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Document summary length in words (max): </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SummaryLength\">\n");
4086     foreach $ItemEntry ( @main::SummaryLengths ) {
4087     $Value = (defined($SummaryLength) && ($SummaryLength eq $ItemEntry)) ? "SELECTED" : "";
4088     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
4089     }
4090     print("</SELECT></TD></TR>\n");
4091     }
4092    
4093    
4094     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4095    
4096     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Document Retrieval Preferences: </B> </TD></TR>\n");
4097    
4098     # Send a pull-down which allows the user to select whether to display summaries or not, and how long we want them
4099     if ( defined($main::ConfigurationData{'allow-similiar-search'}) && ($main::ConfigurationData{'allow-similiar-search'} eq "yes") ) {
4100    
4101     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Number of similar documents retrieved (max): </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SimilarDocuments\">\n");
4102     foreach $ItemEntry ( @main::SimilarDocuments ) {
4103     $Value = (defined($SimilarDocuments) && ($SimilarDocuments eq $ItemEntry)) ? "SELECTED" : "";
4104     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
4105     }
4106     print("</SELECT></TD></TR>\n");
4107     }
4108    
4109    
4110    
4111    
4112     # Are regular searches enabled?
4113     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4114    
4115     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4116    
4117     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Saved Searches Defaults: </B> </TD></TR>\n");
4118    
4119     # Send a pull-down which allows the user to select the automatic search frequency (default to weekly)
4120     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Saved search frequency: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
4121     foreach $ItemEntry ( @main::SearchFrequencies ) {
4122     $Value = (defined($SearchFrequency) && ($SearchFrequency eq $ItemEntry)) ? "SELECTED" : "";
4123     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry \n");
4124     }
4125     print("</SELECT> </TD></TR>\n");
4126    
4127     # Send a pull-down which allows the user to select the automatic search delivery format
4128     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Saved search delivery format: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryFormat\">\n");
4129     foreach $ItemEntry ( sort(keys(%main::DeliveryFormats)) ) {
4130     $Value = (defined($DeliveryFormat) && ($DeliveryFormat eq $ItemEntry)) ? "SELECTED" : "";
4131     print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::DeliveryFormats{$ItemEntry}\n");
4132     }
4133     print("</SELECT> </TD></TR>\n");
4134    
4135     # Send a pull-down which allows the user to select the automatic delivery method
4136     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Saved search delivery method: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
4137     foreach $ItemEntry ( sort(keys(%main::DeliveryMethods)) ) {
4138     $Value = (defined($DeliveryMethod) && ($DeliveryMethod eq $ItemEntry)) ? "SELECTED" : "";
4139     print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::DeliveryMethods{$ItemEntry}\n");
4140     }
4141     print("</SELECT> </TD></TR>\n");
4142     }
4143    
4144    
4145     print("</FORM>\n");
4146     print("</TABLE>\n");
4147    
4148    
4149    
4150     # Bail from the settings
4151     bailFromGetUserSettings:
4152    
4153     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4154     undef(%Value);
4155     $Value{'GetUserSettings'} = "GetUserSettings";
4156     &vSendMenuBar(%Value);
4157     undef(%Value);
4158    
4159     &vSendHTMLFooter;
4160    
4161     return;
4162    
4163     }
4164    
4165    
4166    
4167    
4168    
4169    
4170     #--------------------------------------------------------------------------
4171     #
4172     # Function: vSetUserSettings()
4173     #
4174     # Purpose: This function saves the user setting
4175     #
4176     # Called by:
4177     #
4178     # Parameters: void
4179     #
4180     # Global Variables: %main::ConfigurationData, %main::FormData,
4181     # $main::UserSettingsFilePath, $main::RemoteUser,
4182     #
4183     # Returns: void
4184     #
4185     sub vSetUserSettings {
4186    
4187     my (%Value);
4188    
4189    
4190     # Return an error if the remote user name/account directory is not defined
4191     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4192     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4193     &vSendHTMLFooter;
4194     return;
4195     }
4196    
4197    
4198     # Make sure that we send the header
4199     &vSendHTMLHeader("My Settings", undef);
4200     undef(%Value);
4201     &vSendMenuBar(%Value);
4202    
4203    
4204     # Save the user settings
4205     undef(%Value);
4206     $Value{'UserName'} = $main::FormData{'UserName'};
4207     $Value{'EmailAddress'} = $main::FormData{'EmailAddress'};
4208     $Value{'DefaultSearch'} = $main::FormData{'DefaultSearch'};
4209 dpavlin 1.15 $Value{'SelectedDatabases'} = $main::FormData{'Database'};
4210 dpavlin 1.1 if ( defined($Value{'SelectedDatabases'}) ) {
4211     $Value{'SelectedDatabases'} =~ s/\0/,/g;
4212     }
4213     $Value{'SearchHistory'} = $main::FormData{'SearchHistory'};
4214     $Value{'SearchFrequency'} = $main::FormData{'SearchFrequency'};
4215     $Value{'DeliveryFormat'} = $main::FormData{'DeliveryFormat'};
4216     $Value{'DeliveryMethod'} = $main::FormData{'DeliveryMethod'};
4217     $Value{'SummaryType'} = $main::FormData{'SummaryType'};
4218     $Value{'SummaryLength'} = $main::FormData{'SummaryLength'};
4219     $Value{'SimilarDocuments'} = $main::FormData{'SimilarDocuments'};
4220    
4221    
4222     # Save the user settings file
4223     if ( &iSaveXMLFileFromHash($main::UserSettingsFilePath, "UserSettings", %Value) ) {
4224    
4225     print("<H3> Postavke: </H3>\n");
4226     print("<H3><CENTER> Postavke su uspje¹no snimljene! </CENTER></H3>\n");
4227     print("<P>\n");
4228     }
4229     else {
4230    
4231     # The settings could not be saved, so we inform the user of the fact
4232     &vHandleError("User Settings", "Sorry, we failed to saved your settings");
4233     }
4234    
4235    
4236    
4237     # Bail from the settings
4238     bailFromSetUserSettings:
4239    
4240     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4241     undef(%Value);
4242     &vSendMenuBar(%Value);
4243    
4244     &vSendHTMLFooter;
4245    
4246     return;
4247    
4248     }
4249    
4250    
4251    
4252    
4253    
4254    
4255     #--------------------------------------------------------------------------
4256     #
4257     # Function: vPurgeSearchHistory()
4258     #
4259     # Purpose: This function purges the search history files.
4260     #
4261     # Called by:
4262     #
4263     # Parameters: void
4264     #
4265     # Global Variables: $main::DefaultMaxSearchHistory, $main::UserSettingsFilePath,
4266     # $main::SearchHistoryFileNamePrefix, $main::UserAccountDirectoryPath
4267     #
4268     # Returns: void
4269     #
4270     sub vPurgeSearchHistory {
4271    
4272     my ($MaxSearchHistory, @SearchHistoryList, $SearchHistoryEntry);
4273    
4274    
4275     # Return if the remote user name/account directory is not defined
4276     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4277     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4278     &vSendHTMLFooter;
4279     return;
4280     }
4281    
4282    
4283     # Get the max number of entries in the search history
4284     $MaxSearchHistory = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SearchHistory");
4285    
4286     # Set the detault max number of entries if it was not gotten from the user settings
4287     if ( !defined($MaxSearchHistory) ) {
4288     $MaxSearchHistory = $main::DefaultMaxSearchHistory;
4289     }
4290    
4291    
4292     # Read all the search history files
4293     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4294     @SearchHistoryList = map("$main::UserAccountDirectoryPath/$_" ,
4295     reverse(sort(grep(/$main::SearchHistoryFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
4296     closedir(USER_ACCOUNT_DIRECTORY);
4297    
4298    
4299     # Purge the excess search history files
4300     if ( scalar(@SearchHistoryList) > $MaxSearchHistory ) {
4301    
4302     # Splice out the old stuff, and loop over it deleting the files
4303     for $SearchHistoryEntry ( splice(@SearchHistoryList, $MaxSearchHistory) ) {
4304     unlink($SearchHistoryEntry);
4305     }
4306     }
4307    
4308     return;
4309    
4310     }
4311    
4312    
4313    
4314    
4315     #--------------------------------------------------------------------------
4316     #
4317     # Function: vListSearchHistory()
4318     #
4319     # Purpose: This function lists the search history for the user, the
4320     # entries are listed in reverse chronological order (most
4321     # recent first).
4322     #
4323     # In addition, the search history will be scanned and excess
4324     # searches will be purged.
4325     #
4326     # Called by:
4327     #
4328     # Parameters: void
4329     #
4330     # Global Variables: %main::ConfigurationData, $main::UserAccountDirectoryPath,
4331     # $main::XMLFileNameExtension, $main::SearchHistoryFileNamePrefix,
4332     # $main::RemoteUser
4333     #
4334     # Returns: void
4335     #
4336     sub vListSearchHistory {
4337    
4338     my (@SearchHistoryList, @QualifiedSearchHistoryList, $SearchHistoryEntry);
4339     my ($SearchString, $CreationTime, $SearchAndRfDocumentURL, $HeaderName, $Database);
4340     my ($Value, %Value, @Values);
4341    
4342    
4343     # Return an error if the remote user name/account directory is not defined
4344     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4345     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4346     &vSendHTMLFooter;
4347     return;
4348     }
4349    
4350    
4351    
4352     # Make sure that we send the header
4353     &vSendHTMLHeader("Prija¹nja pretra¾ivanja", undef);
4354     undef(%Value);
4355     $Value{'ListSearchHistory'} = "ListSearchHistory";
4356     &vSendMenuBar(%Value);
4357     undef(%Value);
4358    
4359    
4360     # Purge the search history files
4361     &vPurgeSearchHistory;
4362    
4363    
4364     # Read all the search history files
4365     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4366     @SearchHistoryList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::SearchHistoryFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
4367     closedir(USER_ACCOUNT_DIRECTORY);
4368    
4369    
4370     # Loop over each search history file checking that it is valid
4371     for $SearchHistoryEntry ( @SearchHistoryList ) {
4372    
4373     # Get the header name from the XML search history file
4374     $HeaderName = &sGetObjectTagFromXMLFile($SearchHistoryEntry);
4375    
4376     # Check that the entry is valid and add it to the qualified list
4377     if ( defined($HeaderName) && ($HeaderName eq "SearchHistory") ) {
4378     push @QualifiedSearchHistoryList, $SearchHistoryEntry;
4379     }
4380     else {
4381     # Else we delete this invalid search history file
4382     unlink($SearchHistoryEntry);
4383     }
4384     }
4385    
4386    
4387    
4388     # Display the search history
4389     print("<H3> Prija¹nja pretra¾ivanja: </H3>\n");
4390    
4391     # Print up the search history, if there is none, we put up a nice message
4392     if ( scalar(@QualifiedSearchHistoryList) > 0 ) {
4393    
4394     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
4395    
4396    
4397     for $SearchHistoryEntry ( @QualifiedSearchHistoryList ) {
4398    
4399     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
4400    
4401     # Get information from the XML search history file
4402     ($HeaderName, %Value) = &shGetHashFromXMLFile($SearchHistoryEntry);
4403    
4404     # Get the search file name and encode it
4405     $SearchHistoryEntry = ($SearchHistoryEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $SearchHistoryEntry;
4406     $SearchHistoryEntry = &lEncodeURLData($SearchHistoryEntry);
4407    
4408     $CreationTime = $Value{'CreationTime'};
4409     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
4410     %Value = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
4411     $SearchString = &sMakeSearchString(%Value);
4412     if ( defined($SearchString) ) {
4413     $SearchString =~ s/{.*?}//gs;
4414     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
4415     }
4416     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
4417    
4418    
4419     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD><TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
4420    
4421     # Get the local databases from the search and list their descriptions
4422     if ( defined($Value{'Database'}) ) {
4423    
4424     # Initialize the temp list
4425     undef(@Values);
4426    
4427     # Loop over each database
4428     foreach $Database ( split(/\0/, $Value{'Database'}) ) {
4429     $Value = &lEncodeURLData($Database);
4430     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> ");
4431     }
4432    
4433     # Print the list if there are any entries in it
4434     if ( scalar(@Values) > 0 ) {
4435     printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD><TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n",
4436     scalar(@Values) > 1 ? "s" : "", join(", ", @Values));
4437     }
4438     }
4439    
4440     if ( defined($Value{'RfDocument'}) ) {
4441     print("<TR>");
4442     &bDisplayDocuments("Feedback Document", $Value{'RfDocument'}, "RfDocument", undef, undef, 1);
4443     print("</TR>");
4444     }
4445    
4446     $Value = &sGetPrintableDateFromTime($CreationTime);
4447     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD><TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
4448    
4449     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");
4450    
4451     }
4452    
4453     print("</TABLE>\n");
4454     }
4455     else {
4456     print("<H3><CENTER> Sorry, currently there is no search history. </CENTER></H3>\n");
4457     }
4458    
4459    
4460    
4461     # Bail from the search history
4462     bailFromListSearchHistory:
4463    
4464     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4465     undef(%Value);
4466     $Value{'ListSearchHistory'} = "ListSearchHistory";
4467     &vSendMenuBar(%Value);
4468     undef(%Value);
4469    
4470     &vSendHTMLFooter;
4471    
4472     return;
4473    
4474     }
4475    
4476    
4477    
4478    
4479    
4480     #--------------------------------------------------------------------------
4481     #
4482     # Function: vGetSearchHistory()
4483     #
4484     # Purpose: This function displays a search history file to the user.
4485     #
4486     # Called by:
4487     #
4488     # Parameters: void
4489     #
4490     # Global Variables: %main::ConfigurationData, %main::FormData,
4491     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
4492     # $main::SearchHistoryFileNamePrefix, $main::RemoteUser
4493     #
4494     # Returns: void
4495     #
4496     sub vGetSearchHistory {
4497    
4498     my ($SearchAndRfDocumentURL, $SearchResults, $QueryReport, $CreationTime);
4499     my ($SearchHistoryEntry, $HeaderName, $Status);
4500     my ($Value, %Value);
4501    
4502    
4503    
4504     # Return an error if the remote user name/account directory is not defined
4505     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4506     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4507     &vSendHTMLFooter;
4508     return;
4509     }
4510    
4511    
4512     # Create the search history file name
4513     $SearchHistoryEntry = $main::UserAccountDirectoryPath . "/" . $main::FormData{'SearchHistoryObject'};
4514    
4515    
4516     # Check to see if the XML search history file requested is there
4517     if ( ! -f $SearchHistoryEntry ) {
4518     # Could not find the search history file
4519     &vHandleError("Display Search History", "Sorry, we cant to access this search history object because it is not there");
4520     goto bailFromGetSearchHistory;
4521     }
4522    
4523    
4524     # Get information from the XML search history file
4525     ($HeaderName, %Value) = &shGetHashFromXMLFile($SearchHistoryEntry);
4526    
4527     # Check that the entry is valid
4528     if ( !(defined($HeaderName) && ($HeaderName eq "SearchHistory")) ) {
4529     &vHandleError("Display Search History", "Sorry, this search history object is invalid");
4530     goto bailFromGetSearchHistory;
4531     }
4532    
4533    
4534    
4535     # At this point, the XML search history file is there and is valid,
4536     # so we can go ahead and display it
4537     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
4538     $SearchResults = $Value{'SearchResults'};
4539     $QueryReport = $Value{'QueryReport'};
4540     $CreationTime = $Value{'CreationTime'};
4541    
4542     %main::FormData = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
4543    
4544     # Make sure that we send the header
4545     &vSendHTMLHeader("Display Search History", undef);
4546     undef(%Value);
4547     &vSendMenuBar(%Value);
4548    
4549    
4550     ($Status, $QueryReport) = &bsDisplaySearchResults("Rezultati prija¹njih pretra¾ivanja:", undef, undef, undef, $SearchResults, $QueryReport, $ENV{'SCRIPT_NAME'}, 1, 1, 1, %main::FormData);
4551    
4552    
4553     # Bail from displaying the search history
4554     bailFromGetSearchHistory:
4555    
4556     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4557     undef(%Value);
4558     &vSendMenuBar(%Value);
4559    
4560     &vSendHTMLFooter;
4561    
4562     return;
4563    
4564     }
4565    
4566    
4567    
4568    
4569    
4570    
4571     #--------------------------------------------------------------------------
4572     #
4573     # Function: vGetSaveSearch()
4574     #
4575     # Purpose: This function displays a form to the user allowing them to save a search
4576     #
4577     # Called by:
4578     #
4579     # Parameters: void
4580     #
4581     # Global Variables: %main::ConfigurationData, %main::FormData,
4582     # $main::UserSettingsFilePath, $main::RemoteUser,
4583     #
4584     # Returns: void
4585     #
4586     sub vGetSaveSearch {
4587    
4588    
4589     my ($SearchString, $Database);
4590     my ($HeaderName, $SearchFrequency, $DeliveryFormat, $DeliveryMethod);
4591     my ($JavaScript, $EmailAddress);
4592     my ($Value, @Values, %Value, $ValueEntry);
4593    
4594    
4595     # Return an error if the remote user name/account directory is not defined
4596     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4597     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4598     &vSendHTMLFooter;
4599     return;
4600     }
4601    
4602    
4603     $JavaScript = '<SCRIPT LANGUAGE="JavaScript">
4604     <!-- hide
4605     function checkForm( Form ) {
4606     if ( !checkField( Form.SearchName, "Search name" ) )
4607     return false
4608     return true
4609     }
4610     function checkField( Field, Name ) {
4611     if ( Field.value == "" ) {
4612     errMsg( Field, "Niste ispunili polje \'"+Name+"\' ." )
4613     return false
4614     }
4615     else {
4616     return true
4617     }
4618     }
4619     function errMsg( Field, Msg ) {
4620     alert( Msg )
4621     Field.focus()
4622     return
4623     }
4624     // -->
4625     </SCRIPT>
4626     ';
4627    
4628    
4629    
4630     # Make sure that we send the header
4631     &vSendHTMLHeader("Save this Search", $JavaScript);
4632     undef(%Value);
4633     &vSendMenuBar(%Value);
4634    
4635    
4636     # Give the user a form to fill out
4637     print("<H3> Saving a search: </H3>\n");
4638    
4639    
4640    
4641     # Get information from the XML saved search file
4642     ($HeaderName, %Value) = &shGetHashFromXMLFile($main::UserSettingsFilePath);
4643    
4644     $SearchFrequency = $Value{'SearchFrequency'};
4645     $DeliveryFormat = $Value{'DeliveryFormat'};
4646     $DeliveryMethod = $Value{'DeliveryMethod'};
4647     $EmailAddress = $Value{'EmailAddress'};
4648    
4649    
4650     # Print up the table start
4651     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
4652    
4653     # Start the form
4654     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetSaveSearch\" onSubmit=\"return checkForm(this)\" METHOD=POST>\n");
4655    
4656     # Send the buttons
4657     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=2> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\"> <INPUT TYPE=SUBMIT VALUE=\"Save this Search\"> </TD></TR>\n");
4658    
4659     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4660    
4661     # Print up the search string
4662     $SearchString = &sMakeSearchString(%main::FormData);
4663     if ( defined($SearchString) ) {
4664     $SearchString =~ s/{.*?}//gs;
4665     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
4666     }
4667     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
4668     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
4669    
4670     # Get the local databases from the search and list their descriptions
4671     if ( defined($main::FormData{'Database'}) ) {
4672    
4673     # Initialize the temp list
4674     undef(@Values);
4675    
4676     foreach $Database ( sort(split(/\0/, $main::FormData{'Database'})) ) {
4677     $Value = &lEncodeURLData($Database);
4678     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> ");
4679     }
4680    
4681     # Print the list if there are any entries in it
4682     if ( scalar(@Values) > 0 ) {
4683     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));
4684     }
4685     }
4686    
4687     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4688    
4689     # Send the search name and search description fields
4690     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Search Name (required): </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"SearchName\" TYPE=TEXT SIZE=45> </TD></TR>\n");
4691    
4692     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Search Description: </TD> <TD ALIGN=LEFT VALIGN=TOP> <TEXTAREA INPUT NAME=\"SearchDescription\" COLS=45 ROWS=6 WRAP=VIRTUAL></TEXTAREA> </TD></TR>\n");
4693    
4694     if ( defined($main::FormData{'RfDocument'}) ) {
4695     print("<TR>\n");
4696     &bDisplayDocuments("Feedback Document", $main::FormData{'RfDocument'}, "RfDocument", undef, undef, 1);
4697     print("</TR>\n");
4698     }
4699    
4700    
4701     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4702    
4703     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");
4704    
4705    
4706    
4707     # Are regular searches enabled?
4708     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4709    
4710     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4711    
4712     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Check to run this search on a regular basis: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT TYPE=CHECKBOX VALUE=\"yes\" NAME=\"Regular\"> </TD></TR>\n");
4713    
4714     # Send a pull-down which allows the user to select the automatic search frequency
4715     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Select the search frequency: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
4716     foreach $ValueEntry ( @main::SearchFrequencies ) {
4717     $Value = (defined($SearchFrequency) && ($SearchFrequency eq $ValueEntry)) ? "SELECTED" : "";
4718     print("<OPTION VALUE=\"$ValueEntry\" $Value> $ValueEntry \n");
4719     }
4720     print("</SELECT> </TD></TR>\n");
4721    
4722     # Send a pull-down which allows the user to select the automatic search delivery format
4723     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Select the delivery format: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryFormat\">\n");
4724     foreach $ValueEntry ( sort(keys(%main::DeliveryFormats)) ) {
4725     $Value = (defined($DeliveryFormat) && ($DeliveryFormat eq $ValueEntry)) ? "SELECTED" : "";
4726     print("<OPTION VALUE=\"$ValueEntry\" $Value> $main::DeliveryFormats{$ValueEntry}\n");
4727     }
4728     print("</SELECT> </TD></TR>\n");
4729    
4730     # Send a pull-down which allows the user to select the automatic search delivery method
4731     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Select the delivery method: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
4732     foreach $ValueEntry ( sort(keys(%main::DeliveryMethods)) ) {
4733     $Value = (defined($DeliveryMethod) && ($DeliveryMethod eq $ValueEntry)) ? "SELECTED" : "";
4734     print("<OPTION VALUE=\"$ValueEntry\" $Value> $main::DeliveryMethods{$ValueEntry}\n");
4735     }
4736     print("</SELECT> </TD></TR>\n");
4737     }
4738    
4739    
4740     # List the hidden fields
4741     %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
4742     foreach $Value ( keys(%Value) ) {
4743     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
4744     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
4745     }
4746     }
4747    
4748     print("</FORM>\n");
4749     print("</TABLE>\n");
4750    
4751     if ( !defined($EmailAddress) &&
4752     (defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes")) ) {
4753     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4754     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");
4755     }
4756    
4757    
4758     # Bail from saving the search
4759     bailFromGetSaveSearch:
4760    
4761     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4762     undef(%Value);
4763     &vSendMenuBar(%Value);
4764    
4765     &vSendHTMLFooter;
4766    
4767     return;
4768    
4769     }
4770    
4771    
4772    
4773    
4774    
4775    
4776     #--------------------------------------------------------------------------
4777     #
4778     # Function: vSetSaveSearch()
4779     #
4780     # Purpose: This function saves that search and search name in a search file
4781     #
4782     # Called by:
4783     #
4784     # Parameters: void
4785     #
4786     # Global Variables: %main::ConfigurationData, %main::FormData,
4787     # $main::UserSettingsFilePath, $main::RemoteUser,
4788     #
4789     # Returns: void
4790     #
4791     sub vSetSaveSearch {
4792    
4793    
4794     my ($SearchAndRfDocumentURL, $SearchString);
4795     my (@SavedSearchList, $SavedSearchEntry, $SavedSearchFilePath);
4796     my ($EmailAddress, $SearchName, $CreationTime, $LastRunTime);
4797     my ($Value, %Value);
4798    
4799    
4800     # Return an error if the remote user name/account directory is not defined
4801     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4802     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4803     &vSendHTMLFooter;
4804     return;
4805     }
4806    
4807    
4808     # Make sure that we send the header
4809     &vSendHTMLHeader("Saèuvana pretra¾ivanja", undef);
4810     undef(%Value);
4811     &vSendMenuBar(%Value);
4812    
4813    
4814     # Check that the required fields are filled in
4815     if ( !defined($main::FormData{'SearchName'}) ) {
4816    
4817     # A required field is missing, so we suggest corrective action to the user.
4818     print("<H3> Snimanje pretra¾ivanja: </H3>\n");
4819     print("<H3><CENTER> Oprostite, nedostaju neke informacije. </CENTER></H3>\n");
4820     print("<P>\n");
4821     print("Polje <B>'search name'</B> mora biti ispunjeno da bi se moglo saèuvati pretra¾ivanje.<P>\n");
4822     print("Kliknite na <B>'Back'</B> u svom browseru, popunite polje koje nedostaje i poku¹ajte ponovo.\n");
4823     print("<P>\n");
4824    
4825     goto bailFromSetSaveSearch;
4826    
4827     }
4828    
4829    
4830     # Read all the saved search files
4831     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4832     @SavedSearchList = map("$main::UserAccountDirectoryPath/$_", grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)));
4833     closedir(USER_ACCOUNT_DIRECTORY);
4834    
4835    
4836     # Loop over each saved search file checking that it is valid
4837     for $SavedSearchEntry ( @SavedSearchList ) {
4838    
4839     $SearchName = &sGetTagValueFromXMLFile($SavedSearchEntry, "SearchName");
4840    
4841     if ( $SearchName eq $main::FormData{'SearchName'} ) {
4842     $SavedSearchFilePath = $SavedSearchEntry;
4843     last;
4844     }
4845     }
4846    
4847     # Check that the saved search file does not already exist
4848     if ( defined($SavedSearchFilePath) && ($SavedSearchFilePath ne "")
4849     && !(defined($main::FormData{'OverWrite'}) && ($main::FormData{'OverWrite'} eq "yes")) ) {
4850    
4851     # There is already a saved search with this name, so we suggest corrective action to the user.
4852     print("<H3> Saving a Search: </H3>\n");
4853     print("<H3><CENTER> Sorry, there is already a saved search with this name. </CENTER></H3>\n");
4854     print("<P>\n");
4855     print("Click <B>'back'</B> on your browser, change the <B>'search name'</B> and try again, \n");
4856     print("alternatively you can check the box which allows you to automatically over-write a saved search with the same name.\n");
4857     print("<P>\n");
4858    
4859     goto bailFromSetSaveSearch;
4860     }
4861    
4862    
4863     # Get the email address of this user
4864     $Value = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
4865    
4866     # Check this user has an email address defined if they want to run the search on a regular basis
4867     if ( !defined($Value) && (defined($main::FormData{'Regular'}) && ($main::FormData{'Regular'} eq "yes")) ) {
4868    
4869     # Regular delivery was requested, but the email address was not specified in the settings
4870     print("<H3> Saving a Search: </H3>\n");
4871     print("<H3><CENTER> Sorry, your email address is not specified in your settings. </CENTER></H3>\n");
4872     print("<P>\n");
4873     print("You need to specify your email address in your settings if you want this search to run on a regular basis, \n");
4874     print("without your email address, we are not able to send you the search result. <P>\n");
4875     print("Click the <B>'Settings'</B> option from the menu sidebar, fill in your email address and save the settings, \n");
4876     print("then click <B>'back'</B> on your browser three times to go back to the form which allows you to save a search.\n");
4877     print("<P>\n");
4878    
4879     goto bailFromSetSaveSearch;
4880     }
4881    
4882    
4883     # All the checks have been passed, so we can go ahead and save the search
4884    
4885     $CreationTime = time();
4886     $LastRunTime = $CreationTime;
4887    
4888     # Erase the search frequency and the delivery method if this is not a regular search
4889     if ( !(defined($main::FormData{'Regular'}) && ($main::FormData{'Regular'} eq "yes")) ) {
4890     $main::FormData{'SearchFrequency'} = "";
4891     $main::FormData{'DeliveryFormat'} = "";
4892     $main::FormData{'DeliveryMethod'} = "";
4893     $LastRunTime = "";
4894     }
4895    
4896    
4897     # Get the URL search string
4898     $SearchAndRfDocumentURL = &sMakeSearchAndRfDocumentURL(%main::FormData);
4899    
4900     # Save the search
4901     if ( &iSaveSearch(undef, $main::FormData{'SearchName'}, $main::FormData{'SearchDescription'}, $SearchAndRfDocumentURL, $main::FormData{'SearchFrequency'}, $main::FormData{'DeliveryFormat'}, $main::FormData{'DeliveryMethod'}, "Active", $CreationTime, $LastRunTime) ) {
4902    
4903     print("<H3> Saving a Search: </H3>\n");
4904     print("<P>\n");
4905     print("<H3><CENTER> Your search was successfully saved. </CENTER></H3>\n");
4906    
4907     # Delete the overwritten search file
4908     if ( defined($SavedSearchFilePath) && ($SavedSearchFilePath ne "") ) {
4909     unlink($SavedSearchFilePath);
4910     }
4911     }
4912     else {
4913    
4914     # The search could not be saved, so we inform the user of the fact
4915     &vHandleError("Saving a Search", "Sorry, we failed to save this search");
4916     goto bailFromSetSaveSearch;
4917     }
4918    
4919    
4920     # Bail from saving the search
4921     bailFromSetSaveSearch:
4922    
4923     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4924     undef(%Value);
4925     &vSendMenuBar(%Value);
4926    
4927     &vSendHTMLFooter;
4928    
4929     return;
4930    
4931     }
4932    
4933    
4934    
4935    
4936    
4937    
4938     #--------------------------------------------------------------------------
4939     #
4940     # Function: vListSavedSearch()
4941     #
4942     # Purpose: This function allows the user list the saved searches and
4943     # sets up the links allowing the user to get a search form
4944     # filled with the search
4945     #
4946     # Called by:
4947     #
4948     # Parameters: void
4949     #
4950     # Global Variables: %main::ConfigurationData, %main::FormData,
4951     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
4952     # $main::SavedSearchFileNamePrefix, $main::RemoteUser
4953     #
4954     # Returns: void
4955     #
4956     sub vListSavedSearch {
4957    
4958     my (@SavedSearchList, @QualifiedSavedSearchList, $SavedSearchEntry, $HeaderName, $SearchString, $Database);
4959     my ($SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $LastRunTime);
4960     my (@Values, $Value, %Value);
4961    
4962    
4963     # Return an error if the remote user name/account directory is not defined
4964     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4965     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4966     &vSendHTMLFooter;
4967     return;
4968     }
4969    
4970    
4971     # Make sure that we send the header
4972     &vSendHTMLHeader("Saèuvana pretra¾ivanja", undef);
4973     undef(%Value);
4974     $Value{'ListSavedSearch'} = "ListSavedSearch";
4975     &vSendMenuBar(%Value);
4976     undef(%Value);
4977    
4978    
4979     # Read all the saved search files
4980     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4981     @SavedSearchList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
4982     closedir(USER_ACCOUNT_DIRECTORY);
4983    
4984    
4985     # Loop over each search history file checking that it is valid
4986     for $SavedSearchEntry ( @SavedSearchList ) {
4987    
4988     # Get the header name from the XML saved search file
4989     $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchEntry);
4990    
4991     # Check that the entry is valid and add it to the qualified list
4992     if ( defined($HeaderName) && ($HeaderName eq "SavedSearch") ) {
4993     push @QualifiedSavedSearchList, $SavedSearchEntry;
4994     }
4995     else {
4996     # Else we delete this invalid saved search file
4997     unlink($SavedSearchEntry);
4998     }
4999     }
5000    
5001    
5002     # Print out the saved searches
5003     print("<H3> Saèuvana pretra¾ivanja: </H3>\n");
5004    
5005    
5006    
5007     # Print up the saved searches, if there is none, we put up a nice message
5008     if ( scalar(@QualifiedSavedSearchList) > 0 ) {
5009    
5010     # Start the table
5011     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
5012    
5013     # Start the form
5014     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
5015    
5016    
5017     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> \n");
5018     print("<SELECT NAME=\"Action\">\n");
5019     print("<OPTION VALUE=\"ActivateSavedSearch\">Aktiviraj oznaèena saèuvana pretra¾ivanja\n");
5020     print("<OPTION VALUE=\"SuspendSavedSearch\">Stavi u mirovanje oznaèena saèuvana pretra¾ivanja\n");
5021     print("<OPTION VALUE=\"DeleteSavedSearch\">Obri¹i oznaèena saèuvana pretra¾ivanja\n");
5022     print("</SELECT>\n");
5023     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
5024     print("</TD></TR>\n");
5025    
5026     for $SavedSearchEntry ( @QualifiedSavedSearchList ) {
5027    
5028     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
5029    
5030     # Get information from the XML saved search file
5031     ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchEntry);
5032    
5033     # Get the saved search file name and encode it
5034     $SavedSearchEntry = ($SavedSearchEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $SavedSearchEntry;
5035     $SavedSearchEntry = &lEncodeURLData($SavedSearchEntry);
5036    
5037    
5038     $SearchName = $Value{'SearchName'};
5039     $SearchDescription = $Value{'SearchDescription'};
5040     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
5041     $SearchFrequency = $Value{'SearchFrequency'};
5042     $SearchStatus = $Value{'SearchStatus'};
5043     $DeliveryFormat = $Value{'DeliveryFormat'};
5044     $DeliveryMethod = $Value{'DeliveryMethod'};
5045     $CreationTime = $Value{'CreationTime'};
5046     $LastRunTime = $Value{'LastRunTime'};
5047    
5048     # Parse the URL Search string into a hash so that we can get at it's components
5049     %Value = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
5050    
5051     $SearchString = &sMakeSearchString(%Value);
5052     if ( defined($SearchString) ) {
5053     $SearchString =~ s/{.*?}//gs;
5054     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
5055     }
5056     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
5057    
5058     # Print the link
5059     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");
5060    
5061     # Print the search description
5062     $SearchDescription = defined($SearchDescription) ? $SearchDescription : "(Nije naveden)";
5063     $SearchDescription =~ s/\n/<BR>/g;
5064     $SearchDescription =~ s/\r/<BR>/g;
5065     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDescription </TD></TR>\n");
5066    
5067     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
5068    
5069     # Get the local databases from the search and list their descriptions
5070     if ( defined($Value{'Database'}) ) {
5071    
5072     # Initialize the temp list
5073     undef(@Values);
5074    
5075     # Loop over each database
5076     foreach $Database ( split(/\0/, $Value{'Database'}) ) {
5077     $Value = &lEncodeURLData($Database);
5078     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> ");
5079     }
5080    
5081     # Print the list if there are any entries in it
5082     if ( scalar(@Values) > 0 ) {
5083     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));
5084     }
5085     }
5086    
5087    
5088     if ( defined($Value{'RfDocument'}) ) {
5089     print("<TR><TD></TD>\n");
5090     &bDisplayDocuments("Feedback Document", $Value{'RfDocument'}, "RfDocument", undef, undef, 1);
5091     print("</TR>\n");
5092     }
5093    
5094     undef(%Value);
5095    
5096    
5097     if ( defined($SearchFrequency) || defined($DeliveryFormat) || defined($DeliveryMethod) ) {
5098     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Run: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchFrequency </TD></TR>\n");
5099     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Delivery format: </TD> <TD ALIGN=LEFT VALIGN=TOP> $main::DeliveryFormats{$DeliveryFormat} </TD></TR>\n");
5100     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Delivery method : </TD> <TD ALIGN=LEFT VALIGN=TOP> $main::DeliveryMethods{$DeliveryMethod} </TD></TR>\n");
5101     }
5102    
5103     $Value = &sGetPrintableDateFromTime($CreationTime);
5104     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5105    
5106    
5107     if ( defined($SearchFrequency) || defined($DeliveryFormat) || defined($DeliveryMethod) ) {
5108    
5109     if ( defined($LastRunTime) ) {
5110     $Value = &sGetPrintableDateFromTime($LastRunTime);
5111     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Last Run: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5112     }
5113    
5114     printf("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Status: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>",
5115     (defined($SearchStatus) && ($SearchStatus eq "Active")) ? "Active" : "Suspended");
5116    
5117     }
5118    
5119     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 pretra¾ivanjem ] </A> </TD></TR>\n");
5120     }
5121    
5122     print("</FORM></TABLE>\n");
5123     }
5124     else {
5125     print("<H3><CENTER> Sorry, currently, there are no saved searches. </CENTER></H3>\n");
5126     }
5127    
5128    
5129    
5130    
5131     # Bail from displaying saved searches
5132     bailFromDisplaySavedSearch:
5133    
5134     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5135     undef(%Value);
5136     $Value{'ListSavedSearch'} = "ListSavedSearch";
5137     &vSendMenuBar(%Value);
5138     undef(%Value);
5139    
5140     &vSendHTMLFooter;
5141    
5142    
5143     return;
5144    
5145     }
5146    
5147    
5148    
5149    
5150    
5151    
5152     #--------------------------------------------------------------------------
5153     #
5154     # Function: vGetSavedSearch()
5155     #
5156     # Purpose: This function gets a saved search.
5157     #
5158     # Called by:
5159     #
5160     # Parameters: void
5161     #
5162     # Global Variables: %main::ConfigurationData, %main::FormData,
5163     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
5164     # $main::SavedSearchFileNamePrefix, $main::RemoteUser
5165     #
5166     # Returns: void
5167     #
5168     sub vGetSavedSearch {
5169    
5170     my ($HeaderName, $SavedSearchFilePath, $SearchAndRfDocumentURL, $DefaultSearch);
5171     my ($Value, %Value);
5172    
5173    
5174     # Return an error if the remote user name/account directory is not defined
5175     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5176     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5177     &vSendHTMLFooter;
5178     return;
5179     }
5180    
5181    
5182     # Set the saved search file path
5183     $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'SavedSearchObject'};
5184    
5185    
5186     # Check to see if the XML saved search file requested is there
5187     if ( ! -f $SavedSearchFilePath ) {
5188     # Could not find the saved search file
5189     &vHandleError("Prikaz saèuvaniog pretra¾ivanja", "Sorry, we cant to access this saved search object because it is not there");
5190     &vSendHTMLFooter;
5191     return;
5192     }
5193    
5194    
5195    
5196     # Get the data from the XML saved search file
5197     $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchFilePath);
5198    
5199     # Check that the entry is valid
5200     if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
5201     &vHandleError("Prikaz saèuvaniog pretra¾ivanja", "Sorry, this saved search object is invalid");
5202     &vSendHTMLFooter;
5203     return;
5204     }
5205    
5206    
5207     # All is fine, so we hand over the hash and get the search
5208     %main::FormData = &hParseURLIntoHashTable(&sGetTagValueFromXMLFile($SavedSearchFilePath, 'SearchAndRfDocumentURL'));
5209    
5210     $ENV{'PATH_INFO'} = "/GetSearch";
5211    
5212     # Display the search form, it will autoset itself from %main::FormData
5213     &vGetSearch;
5214    
5215     return;
5216    
5217     }
5218    
5219    
5220    
5221    
5222    
5223    
5224     #--------------------------------------------------------------------------
5225     #
5226     # Function: vProcessSavedSearch()
5227     #
5228     # Purpose: This function processes a saved search.
5229     #
5230     # Called by:
5231     #
5232     # Parameters: void
5233     #
5234     # Global Variables: %main::ConfigurationData, %main::FormData,
5235     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
5236     # $main::SavedSearchFileNamePrefix, $main::RemoteUser
5237     #
5238     # Returns: void
5239     #
5240     sub vProcessSavedSearch {
5241    
5242     my ($Title, $HeaderName, $SavedSearchFilePath, $SavedSearchObject);
5243     my ($Value, %Value);
5244    
5245    
5246     # Return an error if the remote user name/account directory is not defined
5247     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5248     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5249     &vSendHTMLFooter;
5250     return;
5251     }
5252    
5253    
5254     # Set the title
5255     if ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
5256     $Title = "Obri¹i saèuvana pretra¾ivanja";
5257     }
5258     elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
5259     $Title = "Aktiviraj saèuvana pretra¾ivanja";
5260     }
5261     elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
5262     $Title = "Stavi u mirovanje saèuvana pretra¾ivanja";
5263     }
5264    
5265    
5266     # Make sure that we send the header
5267     &vSendHTMLHeader($Title, undef);
5268     undef(%Value);
5269     &vSendMenuBar(%Value);
5270    
5271    
5272     print("<H3> $Title: </H3>\n");
5273    
5274     # Check to see if the saved search object is defined
5275     if ( ! defined($main::FormData{'SavedSearchObject'}) ) {
5276     # Could not find the saved search object
5277     print("<H3><CENTER> Sorry, no searches were selected. </CENTER></H3>\n");
5278     print("<P>\n");
5279     print("You need to select at least one saved search in order to be able to perform an action on it.\n");
5280     print("<P>\n");
5281     goto bailFromProcessSavedSearch;
5282     }
5283    
5284    
5285    
5286     # Loop over each saved search
5287     foreach $SavedSearchObject ( split(/\0/, $main::FormData{'SavedSearchObject'}) ) {
5288    
5289     # Set the saved search file path
5290     $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/" . $SavedSearchObject;
5291    
5292     # Check to see if the XML saved search file requested is there
5293     if ( ! -f $SavedSearchFilePath ) {
5294     next;
5295     }
5296    
5297     # Get information from the XML saved search file
5298     ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchFilePath);
5299    
5300     # Check that the entry is valid
5301     if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
5302     next;
5303     }
5304    
5305    
5306     if ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
5307     if ( unlink($SavedSearchFilePath) ) {
5308     printf("<P>Successfully deleted: %s\n", $Value{'SearchName'});
5309     }
5310     else {
5311     printf("<P>Failed to delete: %s\n", $Value{'SearchName'});
5312     }
5313     }
5314     elsif ( ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") || ($ENV{'PATH_INFO'} eq "/SuspendSavedSearch") ) {
5315    
5316     if ( !defined($Value{'SearchStatus'}) ) {
5317     printf("<P>Could not %s: %s, as it is not a regular search\n",
5318     ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "activate" : "suspend", $Value{'SearchName'});
5319     }
5320     else {
5321    
5322     $Value{'SearchStatus'} = ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "Active" : "Inactive" ;
5323    
5324     if ( &iSaveXMLFileFromHash($SavedSearchFilePath, "SavedSearch", %Value) ) {
5325     printf("<P>Successfully %s: %s\n",
5326     ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "activated" : "suspended", $Value{'SearchName'});
5327     }
5328     else {
5329     printf("<P>Failed to %s: %s\n",
5330     ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "activated" : "suspended", $Value{'SearchName'});
5331     }
5332     }
5333     }
5334     }
5335    
5336     print("<P>\n");
5337    
5338     # Bail from processing the saved search
5339     bailFromProcessSavedSearch:
5340    
5341     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5342     undef(%Value);
5343     &vSendMenuBar(%Value);
5344    
5345     &vSendHTMLFooter;
5346    
5347     return;
5348    
5349     }
5350    
5351    
5352    
5353    
5354    
5355    
5356     #--------------------------------------------------------------------------
5357     #
5358     # Function: vGetSaveFolder()
5359     #
5360     # Purpose: This function displays a form to the user allowing them to
5361     # save documents to a folder
5362     #
5363     # Called by:
5364     #
5365     # Parameters: void
5366     #
5367     # Global Variables: %main::ConfigurationData, %main::FormData,
5368     # $main::UserSettingsFilePath, $main::RemoteUser,
5369     #
5370     # Returns: void
5371     #
5372     sub vGetSaveFolder {
5373    
5374    
5375     my ($JavaScript);
5376     my ($Value, @Values, %Value, $ValueEntry);
5377    
5378    
5379    
5380     # Return an error if the remote user name/account directory is not defined
5381     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5382     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5383     &vSendHTMLFooter;
5384     return;
5385     }
5386    
5387    
5388     $JavaScript = '<SCRIPT LANGUAGE="JavaScript">
5389     <!-- hide
5390     function checkForm( Form ) {
5391     if ( !checkField( Form.FolderName, "Folder name" ) )
5392     return false
5393     return true
5394     }
5395     function checkField( Field, Name ) {
5396     if ( Field.value == "" ) {
5397     errMsg( Field, "Niste ispunili polje \'"+Name+"\'." )
5398     return false
5399     }
5400     else {
5401     return true
5402     }
5403     }
5404     function errMsg( Field, Msg ) {
5405     alert( Msg )
5406     Field.focus()
5407     return
5408     }
5409     // -->
5410     </SCRIPT>
5411     ';
5412    
5413    
5414     # Make sure that we send the header
5415     &vSendHTMLHeader("Saving a Document Folder", $JavaScript);
5416     undef(%Value);
5417     &vSendMenuBar(%Value);
5418    
5419    
5420     # Check that at least one document was selected
5421     if ( !defined($main::FormData{'Document'}) && !defined($main::FormData{'Documents'}) ) {
5422     print("<H3>Saving a Document Folder:</H3>\n");
5423     print("<H3><CENTER>Sorry, no document(s) were selected for saving.</CENTER></H3>\n");
5424     print("<P>\n");
5425     print("There needs to be a least one document selected in order to save it.\n");
5426     print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
5427     goto bailFromGetSaveFolder;
5428     }
5429    
5430    
5431     # Print up the title
5432     print("<H3> Snimanje foldera s dokumentima: </H3>\n");
5433    
5434     # Print up the form
5435     printf("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetSaveFolder\" onSubmit=\"return checkForm(this)\" METHOD=POST>\n");
5436    
5437     # Print up the table start
5438     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
5439    
5440     # Send the buttons
5441     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=2> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\"> <INPUT TYPE=SUBMIT VALUE=\"Save this Folder\"> </TD></TR>\n");
5442    
5443     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
5444    
5445     # Send the fields
5446     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");
5447    
5448     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");
5449    
5450     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
5451    
5452     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");
5453    
5454     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
5455    
5456     # List the documents
5457     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
5458    
5459     # Undefine the hash table in preparation
5460     undef(%Value);
5461    
5462     # Add document that were specifically selected
5463     if ( defined($main::FormData{'Document'}) ) {
5464     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5465     $Value{$Value} = $Value;
5466     }
5467     }
5468     # Otherwise add documents that were selected by default
5469     elsif ( defined($main::FormData{'Documents'}) ) {
5470     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
5471     $Value{$Value} = $Value;
5472     }
5473     }
5474    
5475     # Assemble the new content
5476     $main::FormData{'Document'} = join("\0", keys(%Value));
5477    
5478     # Delete the old content
5479     delete($main::FormData{'Documents'});
5480    
5481    
5482     if ( defined($main::FormData{'Document'}) ) {
5483     print("<TR>\n");
5484     &bDisplayDocuments("Document", $main::FormData{'Document'}, "Document", undef, undef, 1);
5485     print("</TR>\n");
5486     }
5487     }
5488    
5489    
5490    
5491     # List the hidden fields
5492     %Value = &hParseURLIntoHashTable(&sMakeDocumentURL(%main::FormData));
5493     foreach $Value ( keys(%Value) ) {
5494     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
5495     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
5496     }
5497     }
5498    
5499    
5500     # Retain the 'from' folder name if it is defined as these documents are coming from it
5501     if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
5502     print("<INPUT TYPE=HIDDEN NAME=\"FromDocumentFolderObject\" VALUE=\"$main::FormData{'FromDocumentFolderObject'}\">\n");
5503     }
5504    
5505    
5506     # Retain the 'merge' folder name if it is defined as these documents are coming from them
5507     if ( defined($main::FormData{'MergeDocumentFolderObject'}) ) {
5508     foreach $Value ( split(/\0/, $main::FormData{'MergeDocumentFolderObject'}) ) {
5509     print("<INPUT TYPE=HIDDEN NAME=\"MergeDocumentFolderObject\" VALUE=\"$Value\">\n");
5510     }
5511     }
5512    
5513     print("</TABLE>\n");
5514     print("</FORM>\n");
5515    
5516    
5517     # Bail from saving the document folder
5518     bailFromGetSaveFolder:
5519    
5520     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5521     undef(%Value);
5522     &vSendMenuBar(%Value);
5523    
5524     &vSendHTMLFooter;
5525    
5526     return;
5527    
5528     }
5529    
5530    
5531    
5532    
5533    
5534    
5535     #--------------------------------------------------------------------------
5536     #
5537     # Function: vSetSaveFolder()
5538     #
5539     # Purpose: This function saves that search and search name in a search file
5540     #
5541     # Called by:
5542     #
5543     # Parameters: void
5544     #
5545     # Global Variables: %main::ConfigurationData, %main::FormData,
5546     # $main::UserSettingsFilePath, $main::RemoteUser,
5547     #
5548     # Returns: void
5549     #
5550     sub vSetSaveFolder {
5551    
5552     my ($DocumentFolderFilePath, $HeaderName);
5553     my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
5554     my (@DocumentFolderList, $DocumentFolderEntry);
5555     my ($Document, %Document);
5556     my (%Value, @Values, $Value);
5557    
5558    
5559    
5560     # Return an error if the remote user name/account directory is not defined
5561     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5562     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5563     &vSendHTMLFooter;
5564     return;
5565     }
5566    
5567    
5568    
5569     # Make sure that we send the header
5570     &vSendHTMLHeader("Saving a Document Folder", undef);
5571     undef($Value);
5572     &vSendMenuBar(%Value);
5573    
5574    
5575     # Check that at least one document was selected
5576     if ( !defined($main::FormData{'Document'}) && !defined($main::FormData{'Documents'}) ) {
5577    
5578     print("<H3>Saving a Document Folder:</H3>\n");
5579     print("<H3><CENTER>Sorry, no document(s) were selected for saving.</CENTER></H3>\n");
5580     print("<P>\n");
5581     print("There needs to be a least one document selected in order to save it.\n");
5582     print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
5583    
5584     goto bailFromSetSaveFolder;
5585     }
5586    
5587    
5588     # Check that the required fields are filled in
5589     if ( !(defined($main::FormData{'FolderName'}) || defined($main::FormData{'DocumentFolderObject'})) ) {
5590    
5591     # A required field is missing, so we suggest corrective action to the user.
5592     print("<H3> Spremanje foldera s dokumentima: </H3>\n");
5593     print("<H3><CENTER> Oprostite, nedostaju neke informacije. </CENTER></H3>\n");
5594     print("<P>\n");
5595     print("Polje <B>'folder name'</B> mora biti ispunjeno da bi se mogao kreirati folder s dokumentima.<P>\n");
5596     print("Kliknite na <B>'Back'</B> u svom browseru, ispunite polje koje nedostaje i poku¹ajtwe ponovo.\n");
5597     print("<P>\n");
5598    
5599     goto bailFromSetSaveFolder;
5600     }
5601    
5602    
5603    
5604     # Check that the folder is there if we are saving to an existing folder
5605     if ( defined($main::FormData{'DocumentFolderObject'}) ) {
5606    
5607     # Check the old document folder if it is defined
5608     if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
5609    
5610     # Set the document folder file path
5611     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'FromDocumentFolderObject'};
5612    
5613     # Check to see if the old XML saved search file requested is there
5614     if ( ! -f $DocumentFolderFilePath ) {
5615     # Could not find the old saved search file
5616     &vHandleError("Saving a Document Folder", "Sorry, we cant to access this document folder object because it is not there");
5617     goto bailFromSetSaveFolder;
5618     }
5619    
5620     # Get information from the XML document folder file
5621     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
5622    
5623     # Check that the entry is valid
5624     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
5625     &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
5626     goto bailFromSetSaveFolder;
5627     }
5628     }
5629    
5630    
5631     # Set the document folder file path
5632     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
5633    
5634     # Check to see if the XML saved search file requested is there
5635     if ( ! -f $DocumentFolderFilePath ) {
5636     # Could not find the saved search file
5637     &vHandleError("Saving a Document Folder", "Sorry, we cant to access this document folder object because it is not there");
5638     goto bailFromSetSaveFolder;
5639     }
5640    
5641     # Get information from the XML document folder file
5642     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
5643    
5644     # Check that the entry is valid
5645     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
5646     &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
5647     goto bailFromSetSaveFolder;
5648     }
5649     }
5650     elsif ( defined($main::FormData{'FolderName'}) ) {
5651    
5652     # Get the document folder hash
5653     %Value = &hGetDocumentFolders;
5654    
5655     # Set the path/flag
5656     $DocumentFolderFilePath = $Value{$main::FormData{'FolderName'}};
5657    
5658     # Check that the document folder file does not already exist
5659     if ( defined($DocumentFolderFilePath) && !(defined($main::FormData{'OverWrite'}) && ($main::FormData{'OverWrite'} eq "yes")) ) {
5660    
5661     # There is already a document folder with this name, so we suggest corrective action to the user.
5662     print("<H3> Snimanje foldera s dokumentima: </H3>\n");
5663     print("<H3><CENTER> Oprostite, veæ postoji folder s tim imenom. </CENTER></H3>\n");
5664     print("<P>\n");
5665     print("Kliknite na <B>'Back'</B> u svom browseru, promijenite <B>'ime foldera'</B> i poku¹ate ponovo. \n");
5666     print("Alternativno, klikom na kvadratiæ, mo¾ete odabrati da ¾elite postojeæi folder zamijeniti ovim.\n");
5667     print("<P>\n");
5668    
5669     goto bailFromSetSaveFolder;
5670     }
5671     }
5672    
5673    
5674     # Save information in the folder
5675     if ( defined($main::FormData{'DocumentFolderObject'}) ) {
5676    
5677     # Get the data from the XML document folder file
5678     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
5679    
5680     # Check that the entry is valid
5681     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
5682     &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
5683     goto bailFromGetSavedSearch;
5684     }
5685    
5686     $FolderName = $Value{'FolderName'};
5687     $FolderDescription = $Value{'FolderDescription'};
5688     $FolderDocuments = $Value{'FolderDocuments'};
5689     $CreationTime = $Value{'CreationTime'};
5690     $UpdateTime = time();
5691    
5692    
5693     # Merge the documents
5694     if ( defined($FolderDocuments) || defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
5695    
5696     # Undefine the hash table in preparation
5697     undef(%Value);
5698    
5699     # Make a hash table from the documents already in the document folder
5700     if ( defined($FolderDocuments) ) {
5701     foreach $Value ( split(/\0/, $FolderDocuments) ) {
5702     $Value{$Value} = $Value;
5703     }
5704     }
5705    
5706     # Add document that were specifically selected
5707     if ( defined($main::FormData{'Document'}) ) {
5708     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5709     $Value{$Value} = $Value;
5710     }
5711     }
5712     # Otherwise add documents that were selected by default
5713     elsif ( defined($main::FormData{'Documents'}) ) {
5714     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
5715     $Value{$Value} = $Value;
5716     }
5717     }
5718    
5719     # Assemble the new content
5720     $FolderDocuments = join("\0", keys(%Value));
5721    
5722     # Delete the old content
5723     delete($main::FormData{'Document'});
5724     delete($main::FormData{'Documents'});
5725     }
5726    
5727     }
5728     elsif ( defined($main::FormData{'FolderName'}) ) {
5729    
5730     $FolderName = $main::FormData{'FolderName'};
5731     $FolderDescription = $main::FormData{'FolderDescription'};
5732    
5733     # Merge the documents
5734     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) {
5735    
5736     # Undefine the hash table in preparation
5737     undef(%Value);
5738    
5739     # Add document that were specifically selected
5740     if ( defined($main::FormData{'Document'}) ) {
5741     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5742     $Value{$Value} = $Value;
5743     }
5744     }
5745     # Otherwise add documents that were selected by default
5746     elsif ( defined($main::FormData{'Documents'}) ) {
5747     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
5748     $Value{$Value} = $Value;
5749     }
5750     }
5751    
5752     # Assemble the new content
5753     $main::FormData{'Document'} = join("\0", keys(%Value));
5754    
5755     # Delete the old content
5756     delete($main::FormData{'Documents'});
5757     }
5758    
5759     $FolderDocuments = $main::FormData{'Document'};
5760     $CreationTime = time();
5761     $UpdateTime = time();
5762     }
5763    
5764    
5765     # Save the document folder to a new file
5766     if ( &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) ) {
5767    
5768     # Are we pulling these documents from an existing folder?
5769     if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
5770    
5771     # Set the document folder file path
5772     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'FromDocumentFolderObject'};
5773    
5774     # Get information from the XML document folder file
5775     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
5776    
5777    
5778     $FolderName = $Value{'FolderName'};
5779     $FolderDescription = $Value{'FolderDescription'};
5780     $FolderDocuments = $Value{'FolderDocuments'};
5781     $CreationTime = $Value{'CreationTime'};
5782     $UpdateTime = time();
5783    
5784    
5785     # Make a hash table from the documents selected for deletion, this serves as
5786     # a lookup table when we loop through the existing documents
5787     undef(%Value);
5788     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5789     $Value{$Value} = 1;
5790     }
5791    
5792     # Parse out of the existing documents into a list
5793     foreach $Value ( split(/\0/, $FolderDocuments) ) {
5794     # Add the document if it is not on the deletion list
5795     if ( !defined($Value{$Value}) ) {
5796     push @Values, $Value;
5797     }
5798     }
5799     $FolderDocuments = join("\0", @Values);
5800    
5801    
5802     # Save the document folder
5803     &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
5804    
5805     }
5806    
5807     if ( defined($main::FormData{'MergeDocumentFolderObject'}) ) {
5808     @Values = split(/\0/, $main::FormData{'MergeDocumentFolderObject'});
5809     foreach $Value ( @Values ) {
5810     # Set the document folder file path
5811     if ( !(defined($main::FormData{'DocumentFolderObject'}) && ($main::FormData{'DocumentFolderObject'} eq $Value))) {
5812     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $Value;
5813     unlink($DocumentFolderFilePath);
5814     }
5815     }
5816     }
5817    
5818     print("<H3> Saving a Document Folder: </H3>\n");
5819     print("<P>\n");
5820     print("<H3><CENTER> Your document folder was successfully saved. </CENTER></H3>\n");
5821    
5822    
5823     }
5824     else {
5825    
5826     # The document folder could not be saved, so we inform the user of the fact
5827     &vHandleError("Saving a Document Folder", "Sorry, we failed to save this document folder");
5828     goto bailFromSetSaveFolder;
5829     }
5830    
5831    
5832     # Bail from saving the document folder
5833     bailFromSetSaveFolder:
5834    
5835     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5836     undef(%Value);
5837     &vSendMenuBar(%Value);
5838    
5839     &vSendHTMLFooter;
5840    
5841     return;
5842    
5843     }
5844    
5845    
5846    
5847    
5848    
5849    
5850     #--------------------------------------------------------------------------
5851     #
5852     # Function: vListFolder()
5853     #
5854     # Purpose: This function allows the user list the document folders and
5855     # sets up the links allowing the user to get a list of the documents
5856     #
5857     # Called by:
5858     #
5859     # Parameters: void
5860     #
5861     # Global Variables: %main::ConfigurationData, %main::FormData,
5862     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
5863     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
5864     #
5865     # Returns: void
5866     #
5867     sub vListFolder {
5868    
5869     my (@DocumentFolderList, %QualifiedDocumentFolders, $DocumentFolderEntry, $HeaderName);
5870     my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
5871     my (@Values, $Value, %Value);
5872    
5873    
5874     # Return an error if the remote user name/account directory is not defined
5875     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5876     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5877     &vSendHTMLFooter;
5878     return;
5879     }
5880    
5881    
5882     # Make sure that we send the header
5883     &vSendHTMLHeader("Document Folders", undef);
5884     undef(%Value);
5885     $Value{'ListFolder'} = "ListFolder";
5886     &vSendMenuBar(%Value);
5887     undef(%Value);
5888    
5889    
5890    
5891     # Print out the document folders
5892     print("<H3> Folderi: </H3>\n");
5893    
5894    
5895     # Get the document folder hash
5896     %QualifiedDocumentFolders = &hGetDocumentFolders;
5897    
5898    
5899     # Print up the document folders, if there is none, we put up a nice message
5900     if ( scalar(keys(%QualifiedDocumentFolders)) > 0 ) {
5901    
5902     # Start the table
5903     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
5904    
5905     # Start the form
5906     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
5907    
5908    
5909     # Print the selector
5910     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3>\n");
5911     print("<SELECT NAME=\"Action\">\n");
5912     print("<OPTION VALUE=\"DeleteFolder\">Obri¹i oznaèene foldere\n");
5913     print("<OPTION VALUE=\"GetMergeFolder\">Spoji oznaèene foldere u novi folder\n");
5914    
5915     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
5916    
5917     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
5918    
5919     # Get the document folder file name and encode it
5920     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
5921     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
5922    
5923     print("<OPTION VALUE=\"SetMergeFolder&ToDocumentFolderObject=$DocumentFolderEntry\">Spoji oznaèene foldere u '$FolderName' folder\n");
5924     }
5925    
5926     print("</SELECT>\n");
5927     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
5928     print("</TD></TR>\n");
5929    
5930    
5931    
5932     # List the folders
5933     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
5934    
5935     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
5936    
5937     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
5938    
5939     # Get information from the XML document folder file
5940     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderEntry);
5941    
5942     # Get the saved search file name and encode it
5943     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
5944     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
5945    
5946    
5947     $FolderName = $Value{'FolderName'};
5948     $FolderDescription = $Value{'FolderDescription'};
5949     $FolderDocuments = $Value{'FolderDocuments'};
5950     $CreationTime = $Value{'CreationTime'};
5951     $UpdateTime = $Value{'UpdateTime'};
5952    
5953    
5954     # Print the link
5955     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");
5956    
5957     # Print the folder description
5958     $FolderDescription = defined($FolderDescription) ? $FolderDescription : "(Nije naveden)";
5959     $FolderDescription =~ s/\n/<BR>/g;
5960     $FolderDescription =~ s/\r/<BR>/g;
5961     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $FolderDescription </TD></TR>\n");
5962    
5963     if ( defined($FolderDocuments) ) {
5964     @Values = split(/\0/, $FolderDocuments);
5965     $Value = scalar( @Values );
5966     }
5967     else {
5968     $Value = 0;
5969     }
5970     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Broj rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5971    
5972    
5973     $Value = &sGetPrintableDateFromTime($CreationTime);
5974     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5975    
5976     $Value = &sGetPrintableDateFromTime($UpdateTime);
5977     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Datum zadnje promijene: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5978    
5979     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");
5980     }
5981    
5982     print("</FORM></TABLE>\n");
5983     }
5984     else {
5985     print("<H3><CENTER> Nema foldera! </CENTER></H3>\n");
5986     }
5987    
5988    
5989    
5990    
5991     # Bail from displaying document folders
5992     bailFromListFolder:
5993    
5994     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5995     undef(%Value);
5996     $Value{'ListFolder'} = "ListFolder";
5997     &vSendMenuBar(%Value);
5998     undef(%Value);
5999    
6000     &vSendHTMLFooter;
6001    
6002    
6003     return;
6004    
6005     }
6006    
6007    
6008    
6009    
6010    
6011    
6012     #--------------------------------------------------------------------------
6013     #
6014     # Function: vMergeFolder()
6015     #
6016     # Purpose: This function deletes a folder.
6017     #
6018     # Called by:
6019     #
6020     # Parameters: void
6021     #
6022     # Global Variables: %main::ConfigurationData, %main::FormData,
6023     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
6024     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
6025     #
6026     # Returns: void
6027     #
6028     sub vMergeFolder {
6029    
6030     my ($Title, $HeaderName, $DocumentFolderFilePath, $DocumentFolderObject, $FolderDocuments);
6031     my ($Value, %Value);
6032    
6033    
6034    
6035     # Return an error if the remote user name/account directory is not defined
6036     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6037     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6038     &vSendHTMLFooter;
6039     return;
6040     }
6041    
6042    
6043    
6044     # Check to see if the document folder object is defined
6045     if ( ! defined($main::FormData{'DocumentFolderObject'}) ) {
6046    
6047     # Could not find the document folder file
6048     &vSendHTMLHeader("Merge Document Folders", undef);
6049     undef(%Value);
6050     &vSendMenuBar(%Value);
6051     print("<H3> Merge Document Folders: </H3>\n");
6052     print("<H3><CENTER> Sorry, no document folders were selected. </CENTER></H3>\n");
6053     print("<P>\n");
6054     print("You need to select at least one document folder in order to be able to perform an action on it.\n");
6055     print("<P>\n");
6056     return;
6057     }
6058    
6059    
6060     # Init the value hash
6061     undef(%Value);
6062    
6063     # Loop over document folder object
6064     $Value = $main::FormData{'DocumentFolderObject'} .
6065     ((defined($main::FormData{'ToDocumentFolderObject'})) ? "\0" . $main::FormData{'ToDocumentFolderObject'} : "");
6066    
6067     foreach $DocumentFolderObject ( split(/\0/, $Value) ) {
6068    
6069     # Set the document folder file path
6070     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $DocumentFolderObject;
6071    
6072     # Check to see if the XML saved search file requested is there
6073     if ( ! -f $DocumentFolderFilePath ) {
6074     next;
6075     }
6076    
6077     # Get information from the XML saved search file
6078     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
6079    
6080     # Check that the entry is valid
6081     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6082     next;
6083     }
6084    
6085     # Get the FolderDocuments symbol
6086     $FolderDocuments = &sGetTagValueFromXMLFile($DocumentFolderFilePath, "FolderDocuments");
6087    
6088     # Add each document to the hash
6089     foreach $Value ( split(/\0/, $FolderDocuments) ) {
6090     $Value{$Value} = $Value;
6091     }
6092     }
6093    
6094     # Set the document URL from the hash
6095     $main::FormData{'Document'} = join("\0", keys(%Value));
6096    
6097    
6098     if ( defined($main::FormData{'DocumentFolderObject'}) ) {
6099     $main::FormData{'MergeDocumentFolderObject'} = $main::FormData{'DocumentFolderObject'};
6100     delete($main::FormData{'DocumentFolderObject'});
6101     }
6102    
6103     if ( defined($main::FormData{'ToDocumentFolderObject'}) ) {
6104     $main::FormData{'DocumentFolderObject'} = $main::FormData{'ToDocumentFolderObject'};
6105     delete($main::FormData{'ToDocumentFolderObject'});
6106     }
6107    
6108    
6109     if ( $ENV{'PATH_INFO'} eq "/GetMergeFolder" ) {
6110     &vGetSaveFolder;
6111     }
6112     elsif ( $ENV{'PATH_INFO'} eq "/SetMergeFolder" ) {
6113     &vSetSaveFolder;
6114     }
6115    
6116    
6117     return;
6118    
6119     }
6120    
6121    
6122    
6123    
6124    
6125    
6126     #--------------------------------------------------------------------------
6127     #
6128     # Function: vProcessFolder()
6129     #
6130     # Purpose: This function deletes a folder.
6131     #
6132     # Called by:
6133     #
6134     # Parameters: void
6135     #
6136     # Global Variables: %main::ConfigurationData, %main::FormData,
6137     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
6138     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
6139     #
6140     # Returns: void
6141     #
6142     sub vProcessFolder {
6143    
6144     my ($Title, $HeaderName, $DocumentFolderFilePath, $DocumentFolderObject);
6145     my ($Value, %Value);
6146    
6147    
6148    
6149     # Return an error if the remote user name/account directory is not defined
6150     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6151     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6152     &vSendHTMLFooter;
6153     return;
6154     }
6155    
6156    
6157    
6158     if ( $ENV{'PATH_INFO'} eq "/DeleteFolder" ) {
6159     $Title = "Delete Document Folders";
6160     }
6161    
6162    
6163     # Make sure that we send the header
6164     &vSendHTMLHeader($Title, undef);
6165     undef(%Value);
6166     &vSendMenuBar(%Value);
6167    
6168     print("<H3> $Title: </H3>\n");
6169    
6170     # Check to see if the document folder object is defined
6171     if ( ! defined($main::FormData{'DocumentFolderObject'}) ) {
6172    
6173     # Could not find the document folder file
6174     print("<H3><CENTER> Sorry, no document folders were selected. </CENTER></H3>\n");
6175     print("<P>\n");
6176     print("You need to select at least one document folder in order to be able to perform an action on it.\n");
6177     print("<P>\n");
6178    
6179     goto bailFromProcessFolder;
6180     }
6181    
6182    
6183     # Loop over document folder object
6184     foreach $DocumentFolderObject ( split(/\0/, $main::FormData{'DocumentFolderObject'}) ) {
6185    
6186     # Set the document folder file path
6187     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $DocumentFolderObject;
6188    
6189     # Check to see if the XML saved search file requested is there
6190     if ( ! -f $DocumentFolderFilePath ) {
6191     printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
6192     next;
6193     }
6194    
6195     # Get information from the XML saved search file
6196     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
6197    
6198     # Check that the entry is valid
6199     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6200     printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
6201     }
6202    
6203    
6204     if ( unlink($DocumentFolderFilePath) ) {
6205     printf("<P>Successfully deleted: %s\n", $Value{'FolderName'});
6206     }
6207     else {
6208     printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
6209     }
6210     }
6211    
6212     print("<P>\n");
6213    
6214     # Bail from processing the document folder
6215     bailFromProcessFolder:
6216    
6217     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6218     undef(%Value);
6219     &vSendMenuBar(%Value);
6220    
6221     &vSendHTMLFooter;
6222    
6223     return;
6224    
6225     }
6226    
6227    
6228    
6229    
6230    
6231    
6232     #--------------------------------------------------------------------------
6233     #
6234     # Function: vGetFolder()
6235     #
6236     # Purpose: This function displays a document folder to the user.
6237     #
6238     # Called by:
6239     #
6240     # Parameters: void
6241     #
6242     # Global Variables: %main::ConfigurationData, %main::FormData,
6243     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
6244     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
6245     #
6246     # Returns: void
6247     #
6248     sub vGetFolder {
6249    
6250     my ($HeaderName, $FolderName, $SelectorText, %ArticleFolder);
6251     my (@DocumentFolderList, $DocumentFolderEntry, %QualifiedDocumentFolders);
6252     my ($Value, %Value);
6253    
6254    
6255     # Return an error if the remote user name/account directory is not defined
6256     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6257     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6258     &vSendHTMLFooter;
6259     return;
6260     }
6261    
6262    
6263    
6264     # Make the document folder file name
6265     $DocumentFolderEntry = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
6266    
6267     # Check to see if the XML document folder file requested is there
6268     if ( ! -f $DocumentFolderEntry ) {
6269     # Could not find the document folders file
6270     &vHandleError("Document Folder", "Sorry, we cant to access this document folder object because it is not there");
6271     goto bailFromGetFolder;
6272     }
6273    
6274     # Get information from the XML document folder file
6275     ($HeaderName, %ArticleFolder) = &shGetHashFromXMLFile($DocumentFolderEntry);
6276    
6277     # Check that the entry is valid
6278     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6279     &vHandleError("Document Folder", "Sorry, this document folder object is invalid");
6280     goto bailFromGetFolder;
6281     }
6282    
6283    
6284     # Make sure we send the header
6285     &vSendHTMLHeader("Document Folder", undef);
6286     undef(%Value);
6287     &vSendMenuBar(%Value);
6288    
6289     print("<H3> Document Folder: </H3>\n");
6290    
6291    
6292     # Start the form
6293     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
6294    
6295    
6296     # Print the selector if there are any documents
6297     if ( defined($ArticleFolder{'FolderDocuments'}) ) {
6298     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
6299     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");
6300     print("<SELECT NAME=\"Action\">\n");
6301     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultates\n");
6302     if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
6303     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
6304     }
6305     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
6306     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
6307     }
6308     print("<OPTION VALUE=\"DeleteDocument&DocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Delete selected documents from this document folder\n");
6309     print("<OPTION VALUE=\"GetSaveFolder&FromDocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Move selected documents to a new document folder\n");
6310    
6311    
6312     # Get the document folder hash
6313     %QualifiedDocumentFolders = &hGetDocumentFolders;
6314    
6315     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
6316    
6317     # Skip this folder
6318     if ( $FolderName eq $ArticleFolder{'FolderName'} ) {
6319     next;
6320     }
6321    
6322     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
6323    
6324     # Get the document folder file name and encode it
6325     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
6326     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
6327    
6328     print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry&FromDocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Move selected documents to the '$FolderName' document folder\n");
6329     }
6330    
6331     print("</SELECT>\n");
6332     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
6333     print("</TD></TR>\n");
6334     print("</TABLE>\n");
6335     }
6336    
6337     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6338    
6339    
6340     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
6341    
6342     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Naziv: </TD> <TD ALIGN=LEFT VALIGN=TOP> $ArticleFolder{'FolderName'} </TD></TR>\n");
6343    
6344     # Print the folder description
6345     $ArticleFolder{'FolderDescription'} = defined($ArticleFolder{'FolderDescription'}) ? $ArticleFolder{'FolderDescription'} : "(No description defined)";
6346     $ArticleFolder{'FolderDescription'} =~ s/\n/<BR>/g;
6347     $ArticleFolder{'FolderDescription'} =~ s/\r/<BR>/g;
6348     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $ArticleFolder{'FolderDescription'} </TD></TR>\n");
6349    
6350    
6351     $Value = &sGetPrintableDateFromTime($ArticleFolder{'CreationTime'});
6352     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
6353    
6354     $Value = &sGetPrintableDateFromTime($ArticleFolder{'UpdateTime'});
6355     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum zadnje promijene: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
6356    
6357     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
6358    
6359    
6360     # Display a button to select all the documents if there are any
6361     if ( defined($ArticleFolder{'FolderDocuments'}) ) {
6362    
6363     $SelectorText = "";
6364    
6365     # Loop over each entry folder documents
6366     foreach $Value ( split(/\0/, $ArticleFolder{'FolderDocuments'}) ) {
6367     $SelectorText .= (($SelectorText ne "") ? "|" : "") . $Value;
6368     }
6369    
6370     $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
6371     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> $SelectorText </TD></TR>\n");
6372     }
6373    
6374     if ( defined($ArticleFolder{'FolderDocuments'}) ) {
6375     print("<TR>\n");
6376     &bDisplayDocuments("Document", $ArticleFolder{'FolderDocuments'}, "Document", 1, undef, 1);
6377     print("</TR>\n");
6378     }
6379     else {
6380     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2> This document folder does not contain any documents. </TD></TR>\n");
6381     }
6382    
6383     print("</FORM></TABLE>\n");
6384    
6385     # Bail from displaying the document folder
6386     bailFromGetFolder:
6387    
6388     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6389     undef(%Value);
6390     &vSendMenuBar(%Value);
6391    
6392     &vSendHTMLFooter;
6393    
6394     return;
6395    
6396     }
6397    
6398    
6399    
6400    
6401    
6402    
6403     #--------------------------------------------------------------------------
6404     #
6405     # Function: vProcessDocument()
6406     #
6407     # Purpose: This function deletes folder documents
6408     #
6409     # Called by:
6410     #
6411     # Parameters: void
6412     #
6413     # Global Variables: %main::ConfigurationData, %main::FormData,
6414     # $main::UserSettingsFilePath, $main::RemoteUser,
6415     #
6416     # Returns: void
6417     #
6418     sub vProcessDocument {
6419    
6420     my ($Title, $DocumentFolderFilePath, $HeaderName);
6421     my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
6422     my (%Value, @Values, $Value);
6423    
6424    
6425    
6426     # Return an error if the remote user name/account directory is not defined
6427     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6428     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6429     &vSendHTMLFooter;
6430     return;
6431     }
6432    
6433    
6434     # Check to see if the XML document folder is there
6435     if ( !defined($main::FormData{'DocumentFolderObject'}) ) {
6436     # Could not find the document folders file
6437     &vHandleError($Title, "Sorry, the document folder object was not defined");
6438     goto bailFromProcessDocument;
6439     }
6440    
6441    
6442     # Set the title
6443     if ( $ENV{'PATH_INFO'} eq "/DeleteDocument" ) {
6444     $Title = "Delete Folder Documents";
6445     }
6446    
6447    
6448     # Make sure that we send the header
6449     &vSendHTMLHeader($Title, undef);
6450     undef(%Value);
6451     &vSendMenuBar(%Value);
6452    
6453    
6454    
6455     # Check to see if the document folder object is defined
6456     if ( ! (defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) ) {
6457    
6458     # No documents were defined
6459     print("<H3><CENTER> Sorry, no documents were selected. </CENTER></H3>\n");
6460     print("<P>\n");
6461     print("You need to select at least one document in order to be able to perform an action on it.\n");
6462     print("<P>\n");
6463    
6464     goto bailFromProcessDocument;
6465     }
6466    
6467    
6468     # Set the document folder file path
6469     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
6470    
6471    
6472     # Check to see if the XML document folder file requested is there
6473     if ( ! -f $DocumentFolderFilePath ) {
6474     # Could not find the document folders file
6475     &vHandleError($Title, "Sorry, we cant to access this document folder object because it is not there");
6476     goto bailFromProcessDocument;
6477     }
6478    
6479    
6480     # Get information from the XML document folder file
6481     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
6482    
6483     # Check that the entry is valid
6484     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6485     &vHandleError($Title, "Sorry, this document folder object is invalid");
6486     goto bailFromProcessDocument;
6487     }
6488    
6489    
6490    
6491     $FolderName = $Value{'FolderName'};
6492     $FolderDescription = $Value{'FolderDescription'};
6493     $FolderDocuments = $Value{'FolderDocuments'};
6494     $CreationTime = $Value{'CreationTime'};
6495     $UpdateTime = time();
6496    
6497    
6498     # Make a hash table from the documents selected for deletion, this serves as
6499     # a lookup table when we loop through the existing documents
6500     # List the documents
6501     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
6502    
6503     # Undefine the hash table in preparation
6504     undef(%Value);
6505    
6506     # Add document that were specifically selected
6507     if ( defined($main::FormData{'Document'}) ) {
6508     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
6509     $Value{$Value} = $Value;
6510     }
6511     }
6512     # Otherwise add documents that were selected by default
6513     elsif ( defined($main::FormData{'Documents'}) ) {
6514     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
6515     $Value{$Value} = $Value;
6516     }
6517     }
6518     }
6519    
6520    
6521     # Parse out of the existing documents into a list
6522     foreach $Value ( split(/\0/, $FolderDocuments) ) {
6523     # Add the document if it is not on the deletion list
6524     if ( !defined($Value{$Value}) ) {
6525     push @Values, $Value;
6526     }
6527     }
6528     $FolderDocuments = join("\0", @Values);
6529    
6530    
6531     # Save the document folder (now missing the selected documents)
6532     if ( &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) ) {
6533    
6534     print("<H3> $Title: </H3>\n");
6535     print("<P>\n");
6536     print("<H3><CENTER> The folder documents were successfully deleted. </CENTER></H3>\n");
6537    
6538     }
6539     else {
6540    
6541     # The documents coudl not be deleted, so we inform the user of the fact
6542     &vHandleError($Title, "Sorry, we failed to delete the selected folder documents");
6543     goto bailFromProcessDocument;
6544     }
6545    
6546    
6547     # Bail from deleting the documents
6548     bailFromProcessDocument:
6549    
6550     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6551     undef(%Value);
6552     &vSendMenuBar(%Value);
6553    
6554     &vSendHTMLFooter;
6555    
6556     return;
6557    
6558     }
6559    
6560    
6561    
6562    
6563    
6564    
6565     #--------------------------------------------------------------------------
6566     #
6567     # Function: vRunSavedSearches()
6568     #
6569     # Purpose: Run the saved searches which are due
6570     #
6571     # Called by:
6572     #
6573     # Parameters: $PassedFrequency search frequency
6574     #
6575     # Global Variables:
6576     #
6577     # Returns: void
6578     #
6579     sub vRunSavedSearches {
6580    
6581     my ($PassedFrequency) = @_;
6582     my (@UserAccountsDirectoryList, $UserAccountsDirectory, @UserSavedSearchList, $UserSavedSearch);
6583     my (@SavedSearchFilePathList, @QualifiedSaveSearchFilePathList, $SavedSearchFilePath);
6584     my ($SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchString, $DeliveryFormat, $DeliveryMethod, $SearchFrequency, $SearchStatus, $CreationTime, $LastRunTime);
6585     my ($EmailAddress, $NewLastRunTime, $Databases, $HeaderName);
6586     my ($Status, $SearchResults, $FinalSearchString, $SearchResult, $ResultCount, $QueryReport, $ErrorNumber, $ErrorMessage);
6587     my ($ItemName, $MimeType, $HTML, $SavedFileHandle);
6588     my ($Value, %Value, $ValueEntry);
6589    
6590    
6591     # Check that we can actually run saved searches
6592     if ( !(defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes")) ) {
6593     print("Execution error - configuration setting: 'allow-regular-searches', setting not set or disabled.\n");
6594     return;
6595     }
6596    
6597    
6598     # Check that we have a user account directory
6599     if ( !defined($main::ConfigurationData{'user-accounts-directory'}) ) {
6600     print("Execution error - configuration setting: 'user-accounts-directory', setting not set.\n");
6601     }
6602    
6603    
6604     # Check that we have a script URL
6605     if ( !(defined($main::ConfigurationData{'script-url'}) && ($main::ConfigurationData{'script-url'} ne "yes")) ) {
6606     print("Execution error - configuration setting: 'script-url', setting not set.\n");
6607     }
6608    
6609    
6610     # Scoop up all the directories in the user accounts directory
6611     opendir(ACCOUNTS_DIRECTORY, $main::ConfigurationData{'user-accounts-directory'});
6612     @UserAccountsDirectoryList = grep(!/^\.\.?$/, readdir(ACCOUNTS_DIRECTORY));
6613     closedir(ACCOUNTS_DIRECTORY);
6614    
6615     # Loop over each user account
6616     foreach $UserAccountsDirectory ( @UserAccountsDirectoryList ) {
6617    
6618     # Read all the saved searches
6619     opendir(USER_ACCOUNT_DIRECTORY, $main::ConfigurationData{'user-accounts-directory'} . "/" . $UserAccountsDirectory);
6620     @UserSavedSearchList = grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY));
6621     closedir(USER_ACCOUNT_DIRECTORY);
6622    
6623     # And add each to the saved searches list
6624     foreach $UserSavedSearch ( @UserSavedSearchList ) {
6625     push @SavedSearchFilePathList, $main::ConfigurationData{'user-accounts-directory'} . "/" . $UserAccountsDirectory . "/" . $UserSavedSearch;
6626     }
6627     }
6628    
6629    
6630     # Return here if there are no saved search to process
6631     if ( ! @SavedSearchFilePathList ) {
6632     print("Execution warning - no saved searches to process.\n");
6633     return;
6634     }
6635    
6636    
6637     # Loop over each file in the list, checking to see if it is time to
6638     # process this one, if so we add it to the qualified saved search list
6639     foreach $SavedSearchFilePath ( @SavedSearchFilePathList ) {
6640    
6641     # Get the header name from the saved search file
6642     $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchFilePath);
6643    
6644     # Skip this saved search file entry if it is not valid
6645     if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
6646     print("Execution error - invalid saved search object: '$SavedSearchFilePath'.\n");
6647     next;
6648     }
6649    
6650    
6651     # Get the delivery format from the saved search file
6652     $DeliveryFormat = &sGetTagValueFromXMLFile($SavedSearchFilePath, "DeliveryFormat");
6653    
6654     # Check the delivery format, it is undefined if the search is not a regular search
6655     if ( ! defined($DeliveryFormat) ) {
6656     next;
6657     }
6658    
6659     # Check the validity of the delivery format
6660     if ( ! defined($main::DeliveryFormats{$DeliveryFormat}) ) {
6661     print("Execution error - invalid delivery method: '$DeliveryFormat' in saved search: '$SavedSearchFilePath'.\n");
6662     next;
6663     }
6664    
6665    
6666    
6667     # Set the user settings file path name
6668     $main::UserSettingsFilePath = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/") + 1) . $main::UserSettingsFileName . $main::XMLFileNameExtension;
6669    
6670     # Check that this preference file is valid
6671     $HeaderName = &sGetObjectTagFromXMLFile($main::UserSettingsFilePath);
6672    
6673     # Skip this entry if it is not valid
6674     if ( !(defined($HeaderName) && ($HeaderName eq "UserSettings")) ) {
6675     print("Execution error - invalid user settings object: '$main::UserSettingsFilePath'.\n");
6676     next;
6677     }
6678    
6679    
6680     # Get the email address from the user settings file
6681     $EmailAddress = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
6682    
6683     # Skip this entry if it is not valid
6684     if ( !defined($EmailAddress) ) {
6685     print("Execution error - invalid email address in user settings object: '$main::UserSettingsFilePath'.\n");
6686     next;
6687     }
6688    
6689    
6690     # Get the frequency requested for this saved search
6691     $SearchFrequency = &sGetTagValueFromXMLFile($SavedSearchFilePath, "SearchFrequency");
6692    
6693     # Check the search frequency, skip if it is undefined
6694     if ( !defined($SearchFrequency)) {
6695     print("Execution error - undefined search frequency in user settings object: '$main::UserSettingsFilePath'.\n");
6696     next;
6697     }
6698    
6699     # Check the search frequency, skip if it is invalid
6700     $Value = 0;
6701     foreach $ValueEntry ( @main::SearchFrequencies ) {
6702     if ( $ValueEntry eq $SearchFrequency ) {
6703     $Value = 1;
6704     last;
6705     }
6706     }
6707     if ( !$Value ) {
6708     print("Execution error - invalid search frequency: '$SearchFrequency', in user settings object: '$main::UserSettingsFilePath'.\n");
6709     next;
6710     }
6711    
6712    
6713     # Is this the frequency we are currently working on?
6714     if ( index($PassedFrequency, $SearchFrequency) < 0 ) {
6715     next;
6716     }
6717    
6718    
6719     # It is, so we concatenate the saved search file name to the list of
6720     # qualified saved search file names
6721     push @QualifiedSaveSearchFilePathList, $SavedSearchFilePath;
6722     }
6723    
6724    
6725    
6726     # Return here if there are no qualified saved search to process
6727     if ( ! @QualifiedSaveSearchFilePathList ) {
6728     return;
6729     }
6730    
6731    
6732     # Get the current time, this will be used as the new last run time
6733     $NewLastRunTime = time();
6734    
6735    
6736     # Loop each saved search in the qualified saved search list, processing each of them
6737     foreach $SavedSearchFilePath ( @QualifiedSaveSearchFilePathList ) {
6738    
6739     # Get information from the XML saved search file
6740     ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchFilePath);
6741    
6742     $SearchName = $Value{'SearchName'};
6743     $SearchDescription = $Value{'SearchDescription'};
6744     $SearchString = $Value{'SearchString'};
6745     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
6746     $SearchFrequency = $Value{'SearchFrequency'};
6747     $SearchStatus = $Value{'SearchStatus'};
6748     $DeliveryFormat = $Value{'DeliveryFormat'};
6749     $DeliveryMethod = $Value{'DeliveryMethod'};
6750     $CreationTime = $Value{'CreationTime'};
6751     $LastRunTime = $Value{'LastRunTime'};
6752    
6753    
6754     # Check the search status, run the search if it is active
6755     if ( defined($SearchStatus) && ($SearchStatus eq "Active") ) {
6756    
6757     # Get the last run time from the XML saved search file
6758     if ( !defined($LastRunTime) ) {
6759     $LastRunTime = "0";
6760     }
6761    
6762    
6763     # Set the remote user name
6764     $main::RemoteUser = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/"));
6765     $main::RemoteUser = substr($main::RemoteUser, rindex($main::RemoteUser,"/") + 1);
6766    
6767     # Set the user directory path
6768     $main::UserAccountDirectoryPath = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/") + 1);
6769    
6770     # Set the user settings file path name
6771     $main::UserSettingsFilePath = $main::UserAccountDirectoryPath . $main::UserSettingsFileName . $main::XMLFileNameExtension;
6772    
6773     # Get the email address from the user settings file
6774     $EmailAddress = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
6775    
6776     # Parse the URL search string into the form data global
6777     %main::FormData = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
6778    
6779    
6780     ##########################
6781     # Uncomment this to force a check over the complete database rather than
6782     # just getting the documents which changed since the last run
6783     # $LastRunTime = 0;
6784     ##########################
6785    
6786    
6787     # Clear the date restriction fields, they are meaningless in this context
6788     delete($main::FormData{'Since'});
6789     delete($main::FormData{'Before'});
6790    
6791     # Set the last run time restriction
6792     $main::FormData{'LastRunTime'} = $LastRunTime;
6793    
6794    
6795     # Generate the search string
6796     $FinalSearchString = &sMakeSearchString(%main::FormData);
6797    
6798    
6799     # Set the local database names
6800     if ( defined($main::FormData{'Database'}) ) {
6801    
6802     # Set the database variable and convert all the '\0' to ','
6803     $Databases = $main::FormData{'Database'};
6804     $Databases =~ tr/\0/,/;
6805     }
6806    
6807    
6808    
6809     print("Execution - saved search: '$SavedSearchFilePath', database: '$Databases', search: '$FinalSearchString', time: '$LastRunTime'.\n");
6810    
6811     # Run the search
6812     ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Databases, $FinalSearchString, "", 0, $main::DefaultMaxDoc - 1, $main::ConfigurationData{'max-score'});
6813    
6814     if ( ! $Status ) {
6815     ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
6816     print("Execution error - failed to run the search.\n");
6817     print("The following error message was reported: <BR>\n");
6818     print("Error Message: $ErrorMessage <BR>\n");
6819     print("Error Number: $ErrorNumber <BR>\n");
6820     next;
6821     }
6822    
6823    
6824     # Get the number of results we got from the search
6825     $ResultCount = 0;
6826     foreach $SearchResult ( split(/\n/, $SearchResults) ) {
6827    
6828     # Parse the headline, also get the first document item/type
6829     (undef, undef, undef, undef, undef undef, $ItemName, $MimeType, undef) = split(/\t/, $SearchResult, 9);
6830    
6831     # Is this a query report
6832     if ( !(($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType)) ) {
6833     # Increment the result count
6834     $ResultCount++;
6835     }
6836     }
6837    
6838    
6839     # Do we want to deliver email messages with no new results?
6840     if ( defined($main::ConfigurationData{'deliver-empty-results-from-regular-search'}) && ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} eq "no") ) {
6841     if ( $ResultCount == 0 ) {
6842     next;
6843     }
6844     }
6845    
6846    
6847     # Open the mail application, put put an error message if we cant open it and loop to the next saved search
6848     if ( ! open(RESULT_FILE, "| $main::ConfigurationData{'mailer-application'} $EmailAddress ") ) {
6849     print("Execution error - failed to launch mail application: '$main::ConfigurationData{'mailer-application'}', system error: $!.\n");
6850     next;
6851     }
6852    
6853    
6854     # Save the file handle for stdout and select the result file handle as the default handle
6855     $SavedFileHandle = select;
6856     select RESULT_FILE;
6857    
6858    
6859     # Print out the message header (To:)
6860     print ("To: $EmailAddress\n");
6861    
6862     # Print out the message header (From:)
6863     if ( defined($main::ConfigurationData{'site-admin-email'}) && ($main::ConfigurationData{'site-admin-email'} ne "") ) {
6864     print ("From: $main::ConfigurationData{'site-admin-email'}\n");
6865     }
6866    
6867     # Print out the message header (Subject:)
6868     print ("Subject: Results for saved search: $SearchName\n");
6869    
6870    
6871     # Print out the message header (Content-Type)
6872     if ( $DeliveryMethod eq "attachement" ) {
6873     print("Mime-Version: 1.0\n");
6874     print("Content-Type: multipart/mixed; boundary=\"============_-1234567890==_============\"\n");
6875     }
6876     else {
6877     print("Mime-Version: 1.0\n");
6878     printf("Content-Type: %s\n\n", ($DeliveryFormat eq "text/html") ? "text/html" : "text/plain");
6879     }
6880    
6881     # Print out the separating new line between message header and message body
6882     print("\n");
6883    
6884    
6885    
6886     # Print out mime part separator and mime header for the message header
6887     if ( $DeliveryMethod eq "attachement" ) {
6888     print("--============_-1234567890==_============\n");
6889     printf("Content-Type: text/plain; charset=\"us-ascii\"\n\n\n");
6890    
6891     if ( $DeliveryFormat eq "text/plain" ) {
6892     print("The search results are attached to this email message as a plain text\n");
6893     print("file. This file can be opened with a any word processor or text editor.\n");
6894     }
6895     elsif ( $DeliveryFormat eq "text/html" ) {
6896     print("The search results are attached to this email message as an HTML\n");
6897     print("file. This file can be opened with Netscape or Internet Explorer.\n");
6898     }
6899    
6900     print("--============_-1234567890==_============\n");
6901     $Value = "citations." . (($DeliveryFormat eq "text/html") ? "html" : "txt");
6902     print("Content-Type: $DeliveryFormat; name=\"$Value\"\n");
6903     print("Content-Disposition: attachment; filename=\"$Value\"\n\n");
6904     }
6905    
6906    
6907     # Get the current date
6908     $Value = &sGetPrintableDateFromTime();
6909    
6910     # Set the HTML flag
6911     $HTML = ( $DeliveryFormat eq "text/html" ) ? 1 : 0;
6912    
6913     # Write out the search result header
6914     ($Status, $QueryReport) = &bsDisplaySearchResults("Search Results for: $SearchName:", $SearchDescription, $Value, $SearchFrequency, $SearchResults, undef, $main::ConfigurationData{'script-url'}, 1, 1, $HTML, %main::FormData);
6915    
6916    
6917    
6918     # Print out mime part separator and mime header for the message footer
6919     if ( $DeliveryMethod eq "attachement" ) {
6920     print("--============_-1234567890==_============\n");
6921     printf("Content-Type: %s; charset=\"us-ascii\"\n\n\n", ($DeliveryFormat eq "text/html") ? "text/html" : "text/plain");
6922     }
6923    
6924    
6925     # Print out the profile result footer
6926     if ( $DeliveryFormat eq "text/html" ) {
6927     print("<BR><HR>\n");
6928     print("Saved search by the <A HREF=\"$main::ConfigurationData{'script-url'}\">MPS Information Server </A><BR>\n");
6929     print("Created by <A HREF=\"http://www.fsconsult.com/\">FS Consulting, Inc.</A><BR>\n");
6930     print("<HR><BR>\n");
6931     print("</BODY>\n");
6932     }
6933     elsif ( ($DeliveryFormat eq "text/plain") || ($DeliveryFormat eq "text/medline-citation") ) {
6934     print("----------------------------------------------------------------------\n");
6935     print("Saved search by the MPS Information Server [URL: $main::ConfigurationData{'script-url'}].\n");
6936     print("Created by FS Consulting, Inc. [URL: http://www.fsconsult.com/].\n");
6937     print("----------------------------------------------------------------------\n");
6938    
6939     }
6940    
6941     # Print out mime part separator for the end of the message
6942     if ( $DeliveryMethod eq "attachement" ) {
6943     print("--============_-1234567890==_============--\n");
6944     }
6945    
6946    
6947     # Restore the saved file handle
6948     select $SavedFileHandle;
6949    
6950     # Close the result file
6951     close(RESULT_FILE);
6952    
6953     }
6954     else {
6955     print("Execution - saved search: '$SavedSearchFilePath' is currently inactive.\n");
6956     }
6957    
6958     # Save the search object
6959     if ( ! &iSaveSearch($SavedSearchFilePath, $SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $NewLastRunTime) ) {
6960     print("Execution error - failed to save search object: '$SavedSearchFilePath'.\n");
6961     }
6962    
6963     } # foreach ()
6964    
6965     return;
6966    
6967     }
6968    
6969    
6970    
6971    
6972     #--------------------------------------------------------------------------
6973     #
6974     # Function: vLog()
6975     #
6976     # Purpose: This a logging function which logs any passed printf()
6977     # formatted string to STDOUT and the log file if it is defined.
6978     #
6979     # If the log file cannot be opened for appending, nothing will
6980     # be written to it.
6981     #
6982     # Called by:
6983     #
6984     # Parameters: @_
6985     #
6986     # Global Variables: $main::LogFilePath
6987     #
6988     # Returns: void
6989     #
6990     sub vLog {
6991    
6992     # Log to defined log file
6993     if ( defined($main::LogFilePath) && ($main::LogFilePath ne "") && open(LOG_FILE, ">>$main::LogFilePath") ) {
6994     print(LOG_FILE @_);
6995     close(LOG_FILE);
6996     }
6997    
6998     return;
6999    
7000     }
7001    
7002    
7003    
7004    
7005    
7006    
7007     #--------------------------------------------------------------------------
7008     #
7009     # Function: main()
7010     #
7011     # Purpose: main
7012     #
7013     # Called by:
7014     #
7015     # Parameters:
7016     #
7017     # Global Variables:
7018     #
7019     # Returns: void
7020     #
7021    
7022     my ($Status);
7023     my (%Value, $Value);
7024    
7025    
7026    
7027     # Roll over the log file (ignore the status)
7028     # &iRolloverLog($main::LogFilePath, $main::LogFileRollOver);
7029    
7030    
7031     # Verify that we are running the correct perl version, assume upward compatibility
7032     if ( $] < 5.004 ) {
7033     &vLog("Error - this script needs to be run with Perl version 5.004 or better.\n");
7034     &vSendHTMLFooter;
7035     exit (-1);
7036     }
7037    
7038    
7039     # Load up the configuration file
7040     ($Status, %main::ConfigurationData) = &bhReadConfigurationFile($main::ConfigurationFilePath);
7041     if ( ! $Status ) {
7042     &vSendHTMLFooter;
7043     exit (-1);
7044     }
7045    
7046    
7047    
7048     # Set any defaults in the configuration
7049     if ( ! &bSetConfigurationDefaults(\%main::ConfigurationData, \%main::DefaultSettings) ) {
7050     &vSendHTMLFooter;
7051     exit (-1);
7052     }
7053    
7054    
7055     # Check for a minimal configuration
7056     if ( ! &bCheckMinimalConfiguration(\%main::ConfigurationData, \@main::RequiredSettings) ) {
7057     &vSendHTMLFooter;
7058     exit (-1);
7059     }
7060    
7061    
7062     # Check that the configuration paths specified is correct and can be accessed
7063     if ( ! &bCheckConfiguration ) {
7064     &vSendHTMLFooter;
7065     exit (-1);
7066     }
7067    
7068    
7069     # Get the database descriptions
7070     if ( ! &bGetDatabaseDescriptions ) {
7071     &vSendHTMLFooter;
7072     exit (-1);
7073     }
7074    
7075    
7076     # Set up the server
7077     if ( ! &bInitializeServer ) {
7078     &vSendHTMLFooter;
7079     exit (-1);
7080     }
7081    
7082     # fill filed descriptions
7083     &fill_SearchFieldDescriptions_fromDB('ps');
7084    
7085     # Are we running as a CGI-BIN script
7086     if ( $ENV{'GATEWAY_INTERFACE'} ) {
7087    
7088    
7089     # Check the CGI environment
7090     if ( ! &bCheckCGIEnvironment ) {
7091     &vSendHTMLFooter;
7092     exit (-1);
7093     }
7094    
7095    
7096     # Set and verify the environment (dont comment this out).
7097     if ( ! &bSetupCGIEnvironment ) {
7098     &vSendHTMLFooter;
7099     exit (-1);
7100     }
7101    
7102    
7103 dpavlin 1.12 if ( defined($main::FormData{'GetSearch'}) ) {
7104 dpavlin 1.1 $ENV{'PATH_INFO'} = "/GetSearch";
7105 dpavlin 1.12 delete($main::FormData{'GetSearch'});
7106     delete($main::FormData{'GetSearch'});
7107 dpavlin 1.1 }
7108    
7109 dpavlin 1.12 if ( defined($main::FormData{'ListSearchHistory'}) ) {
7110 dpavlin 1.1 $ENV{'PATH_INFO'} = "/ListSearchHistory";
7111 dpavlin 1.12 delete($main::FormData{'ListSearchHistory'});
7112     delete($main::FormData{'ListSearchHistory'});
7113 dpavlin 1.1 }
7114    
7115 dpavlin 1.12 if ( defined($main::FormData{'ListSavedSearch'}) ) {
7116 dpavlin 1.1 $ENV{'PATH_INFO'} = "/ListSavedSearch";
7117 dpavlin 1.12 delete($main::FormData{'ListSavedSearch'});
7118     delete($main::FormData{'ListSavedSearch'});
7119 dpavlin 1.1 }
7120    
7121 dpavlin 1.12 if ( defined($main::FormData{'ListFolder'}) ) {
7122 dpavlin 1.1 $ENV{'PATH_INFO'} = "/ListFolder";
7123 dpavlin 1.12 delete($main::FormData{'ListFolder'});
7124     delete($main::FormData{'ListFolder'});
7125 dpavlin 1.1 }
7126    
7127 dpavlin 1.12 if ( defined($main::FormData{'GetUserSettings'}) ) {
7128 dpavlin 1.1 $ENV{'PATH_INFO'} = "/GetUserSettings";
7129 dpavlin 1.12 delete($main::FormData{'GetUserSettings'});
7130     delete($main::FormData{'GetUserSettings'});
7131 dpavlin 1.1 }
7132    
7133    
7134    
7135     # foreach $Value ( keys (%main::FormData) ) {
7136     # $Status = defined($main::FormData{$Value}) ? $main::FormData{$Value} : "(undefined)";
7137     # &vLog("[\$main::FormData{'$Value'} = '$Status']\n");
7138     # }
7139    
7140     # Check for 'Action', set the PATH_INFO from it if it is set
7141     if ( defined($main::FormData{'Action'}) ) {
7142    
7143     if ( ($Value = index($main::FormData{'Action'}, "&")) > 0 ) {
7144     %Value = &hParseURLIntoHashTable(&lDecodeURLData(substr($main::FormData{'Action'}, $Value)));
7145     $main::FormData{'Action'} = substr($main::FormData{'Action'}, 0, $Value);
7146     foreach $Value ( keys(%Value) ) {
7147     $main::FormData{$Value} = $Value{$Value};
7148     }
7149     }
7150    
7151     $ENV{'PATH_INFO'} = "/" . $main::FormData{'Action'};
7152     delete($main::FormData{'Action'});
7153     }
7154    
7155    
7156     # Default to search if PATH_INFO is not defined
7157     if ( !defined($ENV{'PATH_INFO'}) || ($ENV{'PATH_INFO'} eq "") ) {
7158     $ENV{'PATH_INFO'} = "/GetSearch";
7159     }
7160    
7161    
7162     # Check what was requested and take action appropriately
7163     if ( ($ENV{'PATH_INFO'} eq "/GetSearch") || ($ENV{'PATH_INFO'} eq "/GetSimpleSearch") || ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ) {
7164     &vGetSearch;
7165     }
7166     elsif ( $ENV{'PATH_INFO'} eq "/GetSearchResults" ) {
7167     &vGetSearchResults;
7168     }
7169     elsif ( $ENV{'PATH_INFO'} eq "/GetDatabaseInfo" ) {
7170     &vGetDatabaseInfo;
7171     }
7172     elsif ( $ENV{'PATH_INFO'} eq "/GetDocument" ) {
7173     &vGetDocument;
7174     }
7175     elsif ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
7176     &vGetDocument;
7177     }
7178     elsif ( $ENV{'PATH_INFO'} eq "/GetUserSettings" ) {
7179     &vGetUserSettings;
7180     }
7181     elsif ( $ENV{'PATH_INFO'} eq "/SetUserSettings" ) {
7182     &vSetUserSettings;
7183     }
7184     elsif ( $ENV{'PATH_INFO'} eq "/ListSearchHistory" ) {
7185     &vListSearchHistory;
7186     }
7187     elsif ( $ENV{'PATH_INFO'} eq "/GetSearchHistory" ) {
7188     &vGetSearchHistory;
7189     }
7190     elsif ( $ENV{'PATH_INFO'} eq "/GetSaveSearch" ) {
7191     &vGetSaveSearch;
7192     }
7193     elsif ( $ENV{'PATH_INFO'} eq "/SetSaveSearch" ) {
7194     &vSetSaveSearch;
7195     }
7196     elsif ( $ENV{'PATH_INFO'} eq "/ListSavedSearch" ) {
7197     &vListSavedSearch;
7198     }
7199     elsif ( $ENV{'PATH_INFO'} eq "/GetSavedSearch" ) {
7200     &vGetSavedSearch;
7201     }
7202     elsif ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
7203     &vProcessSavedSearch;
7204     }
7205     elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
7206     &vProcessSavedSearch;
7207     }
7208     elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
7209     &vProcessSavedSearch;
7210     }
7211     elsif ( $ENV{'PATH_INFO'} eq "/GetSaveFolder" ) {
7212     &vGetSaveFolder;
7213     }
7214     elsif ( $ENV{'PATH_INFO'} eq "/SetSaveFolder" ) {
7215     &vSetSaveFolder;
7216     }
7217     elsif ( $ENV{'PATH_INFO'} eq "/ListFolder" ) {
7218     &vListFolder;
7219     }
7220     elsif ( $ENV{'PATH_INFO'} eq "/SetMergeFolder" ) {
7221     &vMergeFolder;
7222     }
7223     elsif ( $ENV{'PATH_INFO'} eq "/GetMergeFolder" ) {
7224     &vMergeFolder;
7225     }
7226     elsif ( $ENV{'PATH_INFO'} eq "/DeleteFolder" ) {
7227     &vProcessFolder;
7228     }
7229     elsif ( $ENV{'PATH_INFO'} eq "/GetFolder" ) {
7230     &vGetFolder;
7231     }
7232     elsif ( $ENV{'PATH_INFO'} eq "/DeleteDocument" ) {
7233     &vProcessDocument;
7234     }
7235     else {
7236     $ENV{'PATH_INFO'} = "/GetSearch";
7237     &vGetSearch;
7238     }
7239    
7240     }
7241     else {
7242    
7243     my ($RunSearches, $Param, $Frequency, $Mday, $Wday);
7244    
7245    
7246     # We are running as a stand alone script
7247    
7248    
7249     #
7250     # Initialize the variables
7251     #
7252    
7253     # Run Searches?
7254     # 0 - dont run searches
7255     # 1 - run searches
7256     $RunSearches = 1;
7257    
7258    
7259     # Init the frequency
7260     $Frequency = "";
7261    
7262     # Check for command parameters
7263     foreach $Param ( @ARGV ) {
7264    
7265     if ( $Param =~ /^-nos/i ) {
7266     # Dont run searches
7267     $RunSearches = 0;
7268     }
7269     elsif ( $Param =~ /^-s/i ) {
7270     # Run searches
7271     $RunSearches = 1;
7272     }
7273     elsif ( $Param =~ /^-d/i ) {
7274     # Want to run the daily
7275     $Frequency .= "|Daily|";
7276     }
7277     elsif ( $Param =~ /^-w/i ) {
7278     # Want to run the weekly
7279     $Frequency .= "|Weekly|";
7280     }
7281     elsif ( $Param =~ /^-m/i ) {
7282     # Want to run the monthly
7283     $Frequency .= "|Monthly|";
7284     }
7285     elsif ( $Param =~ /^-h/i ) {
7286     # help
7287     print("Usage: Search.cgi [-nosearch|-search] [-daily][-weekly][-monthly][-help]\n");
7288     print("\n");
7289     print(" [-nosearch|-search] whether to run or not run searches (default = -search).\n");
7290     print(" [-daily] run daily crawls/searches (overrides default).\n");
7291     print(" [-weekly] run weekly crawls/searches (overrides default).\n");
7292     print(" [-monthly] run monthly crawls/searches (overrides default).\n");
7293     print(" [-help] print the usage and exit.\n");
7294     exit (0);
7295     }
7296     else {
7297     # Invalid param
7298     print("\tError - invalid parameter: '$Param', run 'Search.cgi -help' to get parameter information.\n");
7299     exit (-2);
7300     }
7301     }
7302    
7303    
7304    
7305     # Did we set a frequency usign a command line parameter?
7306     if ( $Frequency eq "" ) {
7307    
7308     # We did not, so we set it based on the following rules
7309     #
7310     # monday-sunday run the daily
7311     # sunday run the weekly
7312     # 1st of the month run the monthly
7313     #
7314    
7315     # Create an ANSI format date/time field
7316     (undef, undef, undef, $Mday, undef, undef, $Wday, undef, undef) = localtime();
7317    
7318     # Always do the daily
7319     $Frequency = "|Daily|";
7320    
7321     # Check for sunday, append the weekly
7322     if ( $Wday == 0 ) {
7323     $Frequency .= "|Weekly|";
7324     }
7325    
7326     # Check for the 1st of the month, append the monthly
7327     if ( $Mday == 1 ) {
7328     $Frequency .= "|Monthly|";
7329     }
7330     }
7331    
7332    
7333     # Log stuff
7334     print("Execution - Frequency: $Frequency\n");
7335    
7336    
7337     # Run the searches
7338     if ( $RunSearches == 1 ) {
7339     &vRunSavedSearches($Frequency);
7340     }
7341     }
7342    
7343    
7344     # Shutdown the server
7345     &bShutdownServer;
7346    
7347    
7348     exit (0);
7349    
7350    
7351    
7352     #--------------------------------------------------------------------------
7353    
7354     # fill SearchFieldDescriptions from one database
7355    
7356     # 2002-06-08 Dobrica Pavlinusic <dpavlin@rot13.org>
7357    
7358     sub fill_SearchFieldDescriptions_fromDB {
7359    
7360     my ($Database) = @_;
7361    
7362     # Get the database field information
7363     my ($Status, $Text) = MPS::GetDatabaseFieldInfo($main::MPSSession, $Database);
7364    
7365     if ( $Status ) {
7366     foreach my $FieldInformation ( split(/\n/, $Text) ) {
7367     my ($FieldName, $FieldDescription, undef) = split(/\t/, $FieldInformation, 3);
7368     $main::SearchFieldDescriptions{$FieldName} = $FieldDescription;
7369     }
7370     }
7371 dpavlin 1.7 }
7372    
7373     #--------------------------------------------------------------------------
7374     # show list of all databases
7375     #
7376     # usage: ShowDatabaseCheckBoxes(@SelectedDatabases)
7377    
7378     sub ShowDatabaseCheckBoxes {
7379     # Parse out the database names and put them into a
7380     # hash table, they should be separated with a '\0'
7381     my %Value;
7382    
7383     foreach my $ItemEntry ( @_ ) {
7384     $Value{$ItemEntry} = $ItemEntry;
7385     }
7386    
7387     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0>\n");
7388 dpavlin 1.15 print "<tr><td colspan=3 align=\"center\">
7389     <font size=-1>Oznaèi
7390     <a href=\"javascript:SetChecked(1)\">sve</a>,
7391     <a href=\"javascript:SetChecked(0)\">niti jednu</a>.
7392     </font>
7393     </td></tr>";
7394 dpavlin 1.7
7395     my @html_database;
7396    
7397     foreach my $key ( sort keys %main::DatabaseSort ) {
7398     my $DatabaseName = $main::DatabaseSort{$key};
7399     my $Value = ((defined($Value{$DatabaseName})) || (scalar(keys(%main::DatabaseDescriptions)) == 1) || !defined($main::RemoteUser) ) ? "CHECKED" : "";
7400     my $ItemEntry = &lEncodeURLData($DatabaseName);
7401     if ($main::DatabaseDescriptions{$DatabaseName}) {
7402     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";
7403     } else {
7404     push @html_database,"<td align=left valign=top>$main::DatabaseDescriptions{$DatabaseName}</td>\n";
7405     }
7406     }
7407    
7408    
7409     if ($main::ConfigurationData{'output-colums'}) {
7410     # create database names in columns
7411    
7412     my $cols = $main::ConfigurationData{'show-nr-colums'};
7413     my $next = int($#html_database/$cols) ;
7414    
7415     for(my $i=0; $i <= $next ; $i++) {
7416     print("<tr>");
7417     for(my $j=0; $j <= $cols; $j++) {
7418     print($html_database[$i+$next*$j+$j] || '');
7419     }
7420     print("</tr>");
7421     }
7422    
7423     } else {
7424     for(my $i=0; $i <= $#html_database ; $i=$i+1) {
7425     print("<tr>",$html_database[$i],"</tr>");
7426     }
7427     }
7428    
7429     print("</TABLE>\n");
7430 dpavlin 1.1 }

  ViewVC Help
Powered by ViewVC 1.1.26