/[webpac-proto]/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.21 - (hide annotations)
Tue Jun 25 19:46:16 2002 UTC (21 years, 9 months ago) by dpavlin
Branch: MAIN
Changes since 1.20: +5 -2 lines
don't display database name in folderlist

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.20 print"<INPUT NAME=\"ListSavedSearch\" TYPE=SUBMIT VALUE=\"Saèuvani upiti\" $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 dpavlin 1.19
1523 dpavlin 1.1
1524 dpavlin 1.19 if ( defined($Content{$FieldName}) && defined($Content{$FieldContent}) ) {
1525     # nuke accented chars
1526     $Content{$FieldContent} =~ tr/Çüéâäùæç³ëÕõî¬ÄÆÉÅåôö¥µ¦¶ÖÜ«»£èáíóú¡±®¾Êê¼ÈºÁÂ̪¯¿ÃãðÐÏËïÒÍÎìÞÙÓÔÑñò©¹ÀÚàÛýÝþ´­½²·¢¸¨ÿØø/CueaauccleOoiZACELlooLlSsOUTtLcaiouAaZzEezCsAAESZzAadDDEdNIIeTUOoNnnSsRUrUyYt'-".'',"'Rr/;
1527     # convert search string to lower case -> make search case insensitive
1528     $Content{$FieldContent} =~ tr/A-Z/a-z/;
1529    
1530     if ($Content{$FieldName} eq "ISBN") {
1531     # fix stupid problem with dashes in data
1532     $Content{$FieldContent} .= "*";
1533     }
1534    
1535     $SearchString .= ($SearchString ne "") ? " AND " : "";
1536     $SearchString .= "$Content{$FieldName}=(" . $Content{$FieldContent} . ")";
1537 dpavlin 1.1 }
1538     }
1539    
1540     # Add the internal search terms
1541    
1542     # Add the date restriction on the load time
1543     if ( defined($Content{'LastRunTime'}) && ($Content{'LastRunTime'} > 0) ) {
1544     $SearchString .= (($SearchString ne "") ? " AND " : "") . "time_t>=$Content{'LastRunTime'}";
1545     }
1546    
1547    
1548     # Add the Past date restriction
1549     if ( defined($Content{'Past'}) && ($Content{'Past'} ne "0") ) {
1550    
1551     $Time = time();
1552     if ( $Content{'Past'} eq "Day" ) {
1553     $Time = &tSubstractFromTime($Time, undef, undef, 1);
1554     }
1555     elsif ( $Content{'Past'} eq "Week" ) {
1556     $Time = &tSubstractFromTime($Time, undef, undef, 7);
1557     }
1558     elsif ( $Content{'Past'} eq "Month" ) {
1559     $Time = &tSubstractFromTime($Time, undef, 1, undef);
1560     }
1561     elsif ( $Content{'Past'} eq "3 Months" ) {
1562     $Time = &tSubstractFromTime($Time, undef, 3, undef);
1563     }
1564     elsif ( $Content{'Past'} eq "6 Months" ) {
1565     $Time = &tSubstractFromTime($Time, undef, 6, undef);
1566     }
1567     elsif ( $Content{'Past'} eq "9 Months" ) {
1568     $Time = &tSubstractFromTime($Time, undef, 9, undef);
1569     }
1570     elsif ( $Content{'Past'} eq "Year" ) {
1571     $Time = &tSubstractFromTime($Time, 1, undef undef);
1572     }
1573    
1574     # Create an ANSI format date/time field
1575     $Date = &sGetAnsiDateFromTime($Time);
1576     $SearchString .= " {DATE>=$Date}";
1577     }
1578    
1579    
1580     # Add the Since date restriction
1581     if ( defined($Content{'Since'}) && ($Content{'Since'} ne "0") ) {
1582     $SearchString .= " {DATE>=$Content{'Since'}0000}";
1583     }
1584    
1585    
1586     # Add the Before date restriction
1587     if ( defined($Content{'Before'}) && ($Content{'Before'} ne "0") ) {
1588     $SearchString .= " {DATE<$Content{'Before'}0000}";
1589     }
1590    
1591    
1592     # Add the document sort order
1593     $SearchString .= defined($Content{'Order'}) ? " {" . $Content{'Order'} . "}" : "";
1594    
1595     # Add the operator
1596     $SearchString .= defined($Content{'Operator'}) ? " {" . $Content{'Operator'} . "}" : "";
1597    
1598    
1599     return (($SearchString ne "") ? $SearchString : undef);
1600    
1601     }
1602    
1603    
1604    
1605    
1606    
1607     #--------------------------------------------------------------------------
1608     #
1609     # Function: hGetSearchStringHash()
1610     #
1611     # Purpose: This function makes a search string hash table from the search
1612     # variables in the content hash
1613     #
1614     # Called by:
1615     #
1616     # Parameters: %Content content hash
1617     #
1618     # Global Variables: void
1619     #
1620     # Returns: the search string hash table, and an empty string if
1621     # nothing relevant is defined in the content hash
1622     #
1623     sub hGetSearchStringHash {
1624    
1625     my (%Content) = @_;
1626    
1627     my ($Content);
1628     my (%Value, @Values, $Value);
1629    
1630    
1631     @Values = split(/ /, defined($Content{'Any'}) ? $Content{'Any'} : "");
1632     foreach $Value ( @Values ) { $Value = lc($Value); $Value{$Value} = $Value };
1633    
1634    
1635     # Add the generic field names
1636     foreach $Value ( 1..100 ) {
1637    
1638     my ($FieldName) = "FieldName" . $Value;
1639     my ($FieldContent) = "FieldContent" . $Value;
1640    
1641     if ( defined($Content{$FieldName}) ) {
1642     @Values = split(/ /, defined($Content{$FieldContent}) ? $Content{$FieldContent} : "");
1643     foreach $Value ( @Values ) { $Value = lc($Value); $Value{$Value} = $Value };
1644     }
1645     }
1646    
1647    
1648     return (%Value);
1649    
1650     }
1651    
1652    
1653    
1654    
1655    
1656     #--------------------------------------------------------------------------
1657     #
1658     # Function: hGetDocumentFolders()
1659     #
1660     # Purpose: This function returns a hash table of all the document folders
1661     #
1662     # Called by:
1663     #
1664     # Parameters: void
1665     #
1666     # Global Variables: void
1667     #
1668     # Returns: a hash table of document folders, the key being the folder name
1669     # and the content being the folder file name
1670     #
1671     sub hGetDocumentFolders {
1672    
1673     my (@DocumentFolderList, $DocumentFolderEntry, $HeaderName, $FolderName, %QualifiedDocumentFolders);
1674    
1675     # Read all the document folder files
1676     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
1677     @DocumentFolderList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::DocumentFolderFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
1678     closedir(USER_ACCOUNT_DIRECTORY);
1679    
1680    
1681     # Loop over each document folder file checking that it is valid
1682     for $DocumentFolderEntry ( @DocumentFolderList ) {
1683    
1684     # Get the header name from the XML document folder file
1685     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderEntry);
1686    
1687     # Check that the entry is valid and add it to the qualified list
1688     if ( defined($HeaderName) && ($HeaderName eq "DocumentFolder") ) {
1689     $FolderName = &sGetTagValueFromXMLFile($DocumentFolderEntry, "FolderName");
1690     $QualifiedDocumentFolders{$FolderName} = $DocumentFolderEntry;
1691     }
1692     else {
1693     # Else we delete this invalid document folder file
1694     unlink($DocumentFolderEntry);
1695     }
1696     }
1697    
1698    
1699     return (%QualifiedDocumentFolders);
1700    
1701     }
1702    
1703    
1704    
1705    
1706    
1707     #--------------------------------------------------------------------------
1708     #
1709     # Function: iSaveSearchHistory()
1710     #
1711     # Purpose: This function saves the passed search to a new
1712     # search history XML file.
1713     #
1714     # Called by:
1715     #
1716     # Parameters: $FileName search history file name ('undef' means create a new file name)
1717     # $SearchAndRfDocumentURL search and RF document URL
1718     # $SearchResults search results
1719     # $QueryReport query report
1720     #
1721     # Global Variables: $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
1722     # $main::SearchHistoryFileNamePrefix
1723     #
1724     # Returns: 0 on error, 1 on success
1725     #
1726     sub iSaveSearchHistory {
1727    
1728     my ($FileName, $SearchAndRfDocumentURL, $SearchResults, $QueryReport) = @_;
1729     my ($SearchHistoryFilePath, %Value);
1730     my ($AnsiDateTime);
1731    
1732    
1733     # Return an error if the user account directory is not defined
1734     if ( !(defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
1735     return (0);
1736     }
1737    
1738     # Create a file name if one was not passed
1739     if ( !defined($FileName) ) {
1740     $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
1741     $SearchHistoryFilePath = $main::UserAccountDirectoryPath . "/". $main::SearchHistoryFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
1742     }
1743     else {
1744     $SearchHistoryFilePath = $FileName;
1745     }
1746    
1747    
1748     # Set the hash from the history information
1749     undef(%Value);
1750     $Value{'CreationTime'} = time();
1751     $Value{'SearchAndRfDocumentURL'} = $SearchAndRfDocumentURL;
1752     $Value{'QueryReport'} = $QueryReport;
1753     $Value{'SearchResults'} = $SearchResults;
1754    
1755    
1756     # Save the search information
1757     if ( ! &iSaveXMLFileFromHash($SearchHistoryFilePath, "SearchHistory", %Value) ) {
1758     # Failed to save the information, so we return an error
1759     return (0);
1760     }
1761    
1762     return (1);
1763    
1764     }
1765    
1766    
1767    
1768    
1769    
1770     #--------------------------------------------------------------------------
1771     #
1772     # Function: iSaveSearch()
1773     #
1774     # Purpose: This function saves the passed search to a new
1775     # search XML file.
1776     #
1777     # Called by:
1778     #
1779     # Parameters: $FileName saved search file name ('undef' means create a new file name)
1780     # $SearchName search name
1781     # $SearchDescription search description
1782     # $SearchAndRfDocumentURL search and RF document URL
1783     # $SearchFrequency search frequency
1784     # $DeliveryFormat delivery format
1785     # $DeliveryMethod delivery method
1786     # $SearchStatus search status
1787     # $CreationTime creation time
1788     # $LastRunTime last run time
1789     #
1790     # Global Variables: $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
1791     # $main::SavedSearchFileNamePrefix
1792     #
1793     # Returns: 0 on error, 1 on success
1794     #
1795     sub iSaveSearch {
1796    
1797     my ($FileName, $SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $LastRunTime) = @_;
1798     my ($SavedSearchFilePath, %Value);
1799     my ($AnsiDateTime);
1800    
1801    
1802     # Return an error if the user account directory is not defined
1803     if ( !(defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
1804     return (0);
1805     }
1806    
1807     # Create a file name if one was not passed
1808     if ( !defined($FileName) ) {
1809     $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
1810     $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/". $main::SavedSearchFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
1811     }
1812     else {
1813     $SavedSearchFilePath = $FileName;
1814     }
1815    
1816    
1817    
1818     # Set the hash from the search information
1819     undef(%Value);
1820     $Value{'SearchName'} = $SearchName;
1821     $Value{'SearchDescription'} = $SearchDescription;
1822     $Value{'SearchAndRfDocumentURL'} = $SearchAndRfDocumentURL;
1823     $Value{'SearchFrequency'} = $SearchFrequency;
1824     $Value{'DeliveryFormat'} = $DeliveryFormat;
1825     $Value{'DeliveryMethod'} = $DeliveryMethod;
1826     $Value{'SearchStatus'} = $SearchStatus;
1827     $Value{'CreationTime'} = $CreationTime;
1828     $Value{'LastRunTime'} = $LastRunTime;
1829    
1830    
1831     # Save the search information
1832     if ( ! &iSaveXMLFileFromHash($SavedSearchFilePath, "SavedSearch", %Value) ) {
1833     # Failed to save the information, so we return an error
1834     return (0);
1835     }
1836    
1837     return (1);
1838    
1839     }
1840    
1841    
1842    
1843    
1844    
1845     #--------------------------------------------------------------------------
1846     #
1847     # Function: iSaveFolder()
1848     #
1849     # Purpose: This function saves the passed folder to a new
1850     # document folder XML file.
1851     #
1852     # Called by:
1853     #
1854     # Parameters: $FileName document folder file name ('undef' means create a new file name)
1855     # $FolderName folder name
1856     # $FolderDescription folder description
1857     # $FolderDocuments folder document
1858     # $CreationTime creation time
1859     # $UpdateTime update time
1860     #
1861     # Global Variables: $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
1862     # $main::DocumentFolderFileNamePrefix
1863     #
1864     # Returns: 0 on error, 1 on success
1865     #
1866     sub iSaveFolder {
1867    
1868     my ($FileName, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) = @_;
1869     my ($DocumentFolderFilePath, %Value);
1870     my ($AnsiDateTime);
1871    
1872    
1873     # Return an error if the user account directory is not defined
1874     if ( !defined($main::RemoteUser) || !defined($main::UserAccountDirectoryPath) ) {
1875     return (0);
1876     }
1877    
1878     # Create a file name if one was not passed
1879     if ( !defined($FileName) ) {
1880     $AnsiDateTime = &sGetAnsiDateFromTime() . &sGetAnsiTimeFromTime();
1881     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/". $main::DocumentFolderFileNamePrefix . "-" . $AnsiDateTime . $main::XMLFileNameExtension;
1882     }
1883     else {
1884     $DocumentFolderFilePath = $FileName;
1885     }
1886    
1887    
1888    
1889     # Set the hash from the folder information
1890     undef(%Value);
1891     $Value{'FolderName'} = $FolderName;
1892     $Value{'FolderDescription'} = $FolderDescription;
1893     $Value{'FolderDocuments'} = $FolderDocuments;
1894     $Value{'CreationTime'} = $CreationTime;
1895     $Value{'UpdateTime'} = $UpdateTime;
1896    
1897    
1898     # Save the document folder information
1899     if ( ! &iSaveXMLFileFromHash($DocumentFolderFilePath, "DocumentFolder", %Value) ) {
1900     # Failed to save the information, so we return an error
1901     return (0);
1902     }
1903    
1904     return (1);
1905    
1906     }
1907    
1908    
1909    
1910    
1911    
1912     #--------------------------------------------------------------------------
1913     #
1914     # Function: bDisplayDocuments()
1915     #
1916     # Purpose: This function displays the document
1917     #
1918     # Called by:
1919     #
1920     # Parameters: $Title title
1921     # $Documents \0 separated document URL
1922     # $FieldName field name
1923     # $Selector true to display selector
1924     # $Selected selector is selected
1925     # $HTML true to display HTML
1926     #
1927     #
1928     # Global Variables: void
1929     #
1930     # Returns: the status
1931     #
1932     sub bDisplayDocuments {
1933    
1934     my ($Title, $Documents, $FieldName, $Selector, $Selected, $HTML) = @_;
1935    
1936     my (@Documents, $Document, $Status, $DocumentInfo, $SelectorText, $SelectedText, $LinkText);
1937     my ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder);
1938     my (%Value, $Value, @Values);
1939    
1940    
1941     # Check input parameters
1942     if ( !defined($Documents) ) {
1943     return (0);
1944     }
1945    
1946    
1947     # Split the documents text into a documents list
1948     @Documents = split(/\0/, $Documents);
1949    
1950    
1951     # Set the field name
1952     $FieldName = (defined($FieldName ) && ($FieldName ne "")) ? $FieldName : "Document";
1953    
1954     # Set the selected text
1955     $SelectedText = ((defined($Selector) && $Selector) && (defined($Selected) && $Selected)) ? "CHECKED" : "";
1956    
1957    
1958     # Print the title
1959     if ( $HTML ) {
1960     printf("<TD ALIGN=LEFT VALIGN=TOP>%s%s:</TD><TD ALIGN=LEFT VALIGN=TOP>\n",
1961 dpavlin 1.20 # defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
1962     $Title);
1963 dpavlin 1.1 }
1964     else {
1965 dpavlin 1.20 # printf("%s%s:\n", defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
1966     print $Title;
1967 dpavlin 1.1 }
1968    
1969    
1970     # Loop over each entry in the documents list
1971     foreach $Document ( @Documents ) {
1972    
1973     # Parse out the document entry
1974     %Value = &hParseURLIntoHashTable($Document);
1975    
1976     # Get the document information
1977     ($Status, $DocumentInfo) = MPS::GetDocumentInfo($main::MPSSession, $Value{'Database'}, $Value{'DocumentID'});
1978    
1979     if ( $Status ) {
1980     ($Headline, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $DocumentInfo, 8);
1981    
1982     # Decode the headline and strip the HTML
1983     $Headline = &lDecodeURLData($Headline);
1984     $Headline =~ s/&nbsp;//gs;
1985     $Headline =~ s/<.*?>//gs;
1986     $Headline =~ s/\s+/ /gs;
1987 dpavlin 1.21 # decode some basic html from headline <b> <i>
1988     $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;
1989 dpavlin 1.1
1990     # Create a generic link for this document
1991     $Value = "";
1992     $Value .= (defined($Value{'Database'}) && ($Value{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Value{'Database'}) : "";
1993     $Value .= (defined($Value{'DocumentID'}) && ($Value{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Value{'DocumentID'}) : "";
1994     $Value .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
1995     $Value .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
1996    
1997    
1998     # Create the selector text
1999     if ( defined($Selector) && $Selector ) {
2000     $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"$FieldName\" VALUE=\"" . substr($Value, 1) . "\" $SelectedText> ";
2001     }
2002     else {
2003     $SelectorText = " - ";
2004     }
2005    
2006     # Create the link text, we use the URL if it is there
2007     if ( defined($URL) && ($URL ne "") ) {
2008     $LinkText = $URL;
2009     }
2010     elsif ( defined($Value{'DocumentID'}) && ($Value{'DocumentID'} ne "") ) {
2011     $LinkText = "$ENV{'SCRIPT_NAME'}/GetDocument?" . substr($Value, 1);
2012     }
2013     else {
2014     $LinkText = "";
2015     }
2016    
2017     # Put up the headline and the score, this one links to the document
2018     if ( $HTML ) {
2019 dpavlin 1.21 # print("$SelectorText <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline <I> ( $main::DatabaseDescriptions{$Value{'Database'}} ) </I> </A> <BR>\n");
2020     print("$SelectorText <A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $Headline </A> <BR>\n");
2021 dpavlin 1.1
2022     # if ( defined($URL) && ($URL ne "") ) {
2023     # $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
2024     # print("<FONT SIZE=-2><A HREF=\"$URL\"> $Value </A></FONT><BR>\n");
2025     # }
2026     }
2027     else {
2028     print("- $Headline ($main::DatabaseDescriptions{$Value{'Database'}})\n URL: $LinkText\n");
2029     }
2030     }
2031     }
2032    
2033     if ( $HTML ) {
2034     print("</TD>\n");
2035     }
2036    
2037    
2038     return (1);
2039    
2040     }
2041    
2042    
2043    
2044    
2045    
2046    
2047     #--------------------------------------------------------------------------
2048     #
2049     # Function: bsDisplaySearchResults()
2050     #
2051     # Purpose: This function displays the search results
2052     #
2053     # Called by:
2054     #
2055     # Parameters: $Title title
2056     # $SearchResults search results
2057     # $SearchDate search date
2058     # $SearchFrequency search frequency
2059     # $SearchDescription search description
2060     # $QueryReport query report
2061     # $ScriptName script name
2062     # $Header true to display header
2063     # $Selector true to display selector
2064     # $HTML true to display HTML
2065     # %Content content hash table
2066     #
2067     #
2068     # Global Variables: %main::ConfigurationData, $main::RemoteUser,
2069     # $main::QueryReportItemName, $main::QueryReportMimeType
2070     #
2071     # Returns: the status and a the query report
2072     #
2073     sub bsDisplaySearchResults {
2074    
2075     my ($Title, $SearchDescription, $SearchDate, $SearchFrequency, $SearchResults, $QueryReport, $ScriptName, $Header, $Selector, $HTML, %Content) = @_;
2076    
2077     my ($SearchString, $SummaryType, $SummaryLength, @SearchResults, $SearchResult, $FinalQueryReport, $ResultCount, %SearchStringHash);
2078     my ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder);
2079     my ($Status, $Text, $MimeTypeName, $SummaryText, $SelectorText, $LinkText, $RuleFlag, $LastItemName);
2080     my (@DocumentFolderList, %QualifiedDocumentFolders, $DocumentFolderEntry, $HeaderName, $FolderName, $Index);
2081     my (@Words, $Word, @OffsetPairs, $OffsetPair, %Offsets, $Offset, $Start, $End, $OldStart, $OldEnd, $CurrentSummaryLength);
2082     my ($DatabaseSummaryFilterKey, $DatabaseSummaryFilterFunction);
2083     my ($Value, %Value, @Values, $ValueEntry);
2084 dpavlin 1.9
2085    
2086 dpavlin 1.1 # Check input parameters
2087     if ( !defined($SearchResults) || !%Content ) {
2088     return (0);
2089     }
2090    
2091     # Split the search results text into a search results list
2092     @SearchResults = split(/\n/, $SearchResults);
2093    
2094    
2095     # First we count up the number of results and scoop up
2096     # any query reports if we need to
2097    
2098     # Initialize the final query report
2099     if ( !defined($QueryReport) ) {
2100     $FinalQueryReport = "";
2101     }
2102     else {
2103     $FinalQueryReport = $QueryReport;
2104     }
2105    
2106    
2107     # Loop over each entry in the search results list
2108     $ResultCount = 0;
2109     foreach $SearchResult ( @SearchResults ) {
2110    
2111     # Parse the headline, also get the first document item/type
2112     ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
2113    
2114     # Is this a query report
2115     if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
2116    
2117     # Retrieve the query report if it was not passed to us
2118     if ( !defined($QueryReport) ) {
2119     ($Status, $Text) = MPS::GetDocument($main::MPSSession, $Database, $DocumentID, $ItemName, $MimeType);
2120    
2121     if ( $Status ) {
2122     # Concatenate it to the query report text we have already got
2123     $FinalQueryReport .= $Text;
2124     }
2125     }
2126     }
2127     else {
2128     # Increment the result count
2129     $ResultCount++;
2130     }
2131     }
2132    
2133    
2134    
2135    
2136     # Finally, we get information we are going to need later on
2137    
2138     # Get the search string
2139     $SearchString = &sMakeSearchString(%Content);
2140     if ( defined($SearchString) ) {
2141     $SearchString =~ s/{.*?}//gs;
2142     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
2143     }
2144     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
2145    
2146     # Get the search string hash
2147     %SearchStringHash = &hGetSearchStringHash(%Content);
2148    
2149     # Do some very basic plural stemming
2150     foreach $Value ( keys (%SearchStringHash) ) {
2151     $Value =~ s/ies\Z/y/g;
2152     $Value =~ s/s\Z//g;
2153     $SearchStringHash{$Value} = $Value;
2154     }
2155    
2156    
2157    
2158     # Get the summary information
2159     if ( defined($main::RemoteUser) ) {
2160    
2161     $SummaryType = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SummaryType");
2162     $SummaryLength = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SummaryLength");
2163    
2164     if ( !(defined($SummaryLength) && ($SummaryLength ne "")) ) {
2165     $SummaryLength = $main::DefaultSummaryLength;
2166     }
2167     if ( !(defined($SummaryType) && ($SummaryType ne "")) ) {
2168     $SummaryType = $main::DefaultSummaryType;
2169     }
2170     }
2171     else {
2172     $SummaryType = $main::DefaultSummaryType;
2173     $SummaryLength = $main::DefaultSummaryLength;
2174     }
2175    
2176    
2177     # Print the header if needed
2178     if ( $Header ) {
2179    
2180     if ( $HTML ) {
2181     # Print the title and the start of the form
2182     printf("<H3>%s</H3>\n", defined($Title) ? $Title : "Rezultati pretra¾ivanja:");
2183    
2184     # Start the form
2185     print("<FORM ACTION=\"$ScriptName\" METHOD=POST>\n");
2186    
2187    
2188     # List the hidden fields
2189     %Value = &hParseURLIntoHashTable(&sMakeSearchURL(%Content));
2190     foreach $Value ( keys(%Value) ) {
2191     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
2192     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
2193     }
2194     }
2195    
2196    
2197     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2198    
2199     # Print the selector
2200 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP>Odabrani su svi rezultati ukoliko niste uèinili nikakav dodatan odabir.</TD><TD ALIGN=RIGHT VALIGN=TOP> \n");
2201 dpavlin 1.1
2202     if ( $ResultCount > 0 ) {
2203    
2204     if ( defined($main::RemoteUser) ) {
2205     print("<SELECT NAME=\"Action\">\n");
2206    
2207     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
2208     if
2209     ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
2210     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
2211     }
2212     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
2213     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
2214     }
2215 dpavlin 1.20 print("<OPTION VALUE=\"GetSaveSearch\">Saèuvaj upit\n");
2216 dpavlin 1.1 print("<OPTION VALUE=\"GetSaveFolder\">Saèuvaj odabrane rezultate u novi folder\n");
2217    
2218     # Get the document folder hash
2219     %QualifiedDocumentFolders = &hGetDocumentFolders;
2220    
2221     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
2222    
2223     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
2224    
2225     # Get the document folder file name and encode it
2226     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
2227     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
2228    
2229     print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry\">Dodaj odabrane rezultate u '$FolderName' folder\n");
2230     }
2231     print("</SELECT>\n");
2232     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
2233     }
2234     else {
2235     print("<SELECT NAME=\"Action\">\n");
2236     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
2237     if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
2238     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
2239     }
2240     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
2241     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
2242     }
2243     print("</SELECT>\n");
2244     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
2245     }
2246     }
2247     else {
2248     if ( defined($main::RemoteUser) ) {
2249     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSaveSearch\">\n");
2250     print("<INPUT TYPE=SUBMIT VALUE=\"Save this search\">\n");
2251     }
2252     }
2253    
2254     print("</TD></TR>\n");
2255     print("</TABLE>\n");
2256     }
2257     else {
2258     printf("%s\n", defined($Title) ? $Title : "Rezultati pretra¾ivanja:");
2259     }
2260    
2261    
2262     # Display the search string
2263     if ( $HTML ) {
2264     print("<CENTER><HR WIDTH=50%></CENTER>\n");
2265     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2266     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
2267     }
2268     else {
2269     print("--------------------------------------------------------------\n");
2270     print(" - Search for : $SearchString\n");
2271     }
2272    
2273    
2274     # Display the description
2275     if ( defined($SearchDescription) ) {
2276     if ( $HTML ) {
2277     $SearchDescription =~ s/\n/<BR>/g;
2278     $SearchDescription =~ s/\r/<BR>/g;
2279     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDescription </TD></TR>\n");
2280     }
2281     else {
2282     print(" - Description : $SearchDescription\n");
2283     }
2284     }
2285    
2286     # Display the date
2287     if ( defined($SearchDate) ) {
2288     if ( $HTML ) {
2289     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Run on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDate </TD></TR>\n");
2290     }
2291     else {
2292     print(" - Run on : $SearchDate\n");
2293     }
2294     }
2295    
2296     # Display the frequency
2297     if ( defined($SearchFrequency) ) {
2298     if ( $HTML ) {
2299     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Frequency: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchFrequency </TD></TR>\n");
2300     }
2301     else {
2302     print(" - Frequency : $SearchFrequency\n");
2303     }
2304     }
2305    
2306    
2307    
2308     # Get the databases from the search and list their descriptions
2309     if ( defined($Content{'Database'}) ) {
2310    
2311     # Initialize the temp list
2312     undef(@Values);
2313    
2314     # Loop over each database
2315     foreach $Database ( split(/\0/, $Content{'Database'}) ) {
2316     $Value = &lEncodeURLData($Database);
2317     if ( $HTML ) {
2318     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> ");
2319     }
2320     else {
2321     push @Values, sprintf("$main::DatabaseDescriptions{$Database} ");
2322     }
2323     }
2324    
2325     # Print the list if there are any entries in it
2326     if ( scalar(@Values) > 0 ) {
2327     if ( $HTML ) {
2328     printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n",
2329     (scalar(@Values) > 1) ? "s" : "", join(", ", @Values));
2330     }
2331     else {
2332     printf(" - Database%s : %s\n", (scalar(@Values) > 1) ? "s" : " ", join(", ", @Values));
2333     }
2334     }
2335     }
2336    
2337    
2338     # Display any feedback documents
2339     if ( defined($Content{'RfDocument'}) ) {
2340     if ( $HTML ) {
2341     print("<TR>\n");
2342     }
2343     &bDisplayDocuments("Feedback Document", $Content{'RfDocument'}, "RfDocument", 1, 1, $HTML);
2344     if ( $HTML ) {
2345     print("</TR>\n");
2346     }
2347     }
2348    
2349    
2350     if ( $HTML ) {
2351     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",
2352     ($ResultCount > 0) ? $ResultCount : "no");
2353    
2354     print("</TABLE>\n");
2355     print("<CENTER><HR WIDTH=50%></CENTER>\n");
2356     }
2357     else {
2358     printf(" - Results : %s\n", ($ResultCount > 0) ? $ResultCount : "no");
2359     print("--------------------------------------------------------------\n\n");
2360     }
2361     }
2362    
2363    
2364     # Start the table
2365     if ( $HTML ) {
2366     print("<!-- searchResults -->\n");
2367     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2368    
2369     # Display a button to select all the documents
2370     if ( $ResultCount > 0 ) {
2371    
2372     if ( defined($Selector) && $Selector ) {
2373    
2374     $SelectorText = "";
2375    
2376     # Loop over each entry in the hits list
2377     foreach $SearchResult ( @SearchResults ) {
2378    
2379     # Parse the headline, also get the first document item/type
2380     ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
2381    
2382     # Skip query reports
2383     if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
2384     next;
2385     }
2386    
2387     $Value = "";
2388     $Value .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2389     $Value .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2390     $Value .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2391     $Value .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2392     $SelectorText .= (($SelectorText ne "") ? "|" : "") . substr($Value, 1);
2393     }
2394    
2395     $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
2396     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> $SelectorText </TD></TR>\n");
2397     }
2398     }
2399     }
2400    
2401    
2402 dpavlin 1.9 ### FIX:: ADD SORT HERE
2403 dpavlin 1.1 if ( $ResultCount > 0 ) {
2404    
2405     # Loop over each entry in the hits list
2406     foreach $SearchResult ( @SearchResults ) {
2407    
2408     # Parse the headline, also get the first document item/type
2409     ($Database, $Headline, $Score, $DocumentID, $Date, $Time, $ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $SearchResult, 11);
2410    
2411     # Skip query reports
2412     if ( ($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType) ) {
2413     next;
2414     }
2415    
2416    
2417     # Put a separator between each entry
2418     if ( defined($Remainder) ) {
2419    
2420     if ( defined($RuleFlag) && ($RuleFlag) ) {
2421     if ( $HTML ) {
2422     print("<TR><TD COLSPAN=3><HR WIDTH=25%></TD></TR>\n");
2423     }
2424     else {
2425     print("--------------------------------------------------------------\n\n");
2426     }
2427     }
2428    
2429     $RuleFlag = 1;
2430     }
2431    
2432    
2433     # Get the summary if needed
2434     if ( defined($main::ConfigurationData{'allow-summary-displays'}) && ($main::ConfigurationData{'allow-summary-displays'} eq "yes") &&
2435     ($SummaryType ne "none") ) {
2436    
2437     ($Status, $Text) = MPS::GetDocument($main::MPSSession, $Database, $DocumentID, $ItemName, $MimeType);
2438    
2439     if ( $Status ) {
2440    
2441     # Then process for each summary type
2442     if ( $SummaryType eq "default" ) {
2443    
2444     $DatabaseSummaryFilterKey = "$main::DatabaseSummaryFilter:$Database:$ItemName:$MimeType";
2445    
2446     # Is a filter defined for this database summary filter key ?
2447     if ( defined($main::DatabaseFilters{$DatabaseSummaryFilterKey}) ) {
2448    
2449     # Pull in the package
2450     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Database"};
2451    
2452     # Filter the document
2453     $Value = $main::DatabaseFilters{$DatabaseSummaryFilterKey};
2454     $DatabaseSummaryFilterFunction = \&$Value;
2455     $Text = $DatabaseSummaryFilterFunction->($Database, $DocumentID, $ItemName, $MimeType, $Text);
2456    
2457     }
2458    
2459     # Truncate the summary to the length requested
2460     if ( defined ($Text) && ($Text ne "") ) {
2461    
2462     $CurrentSummaryLength = 0;
2463     $SummaryText = "";
2464    
2465     # Split the document text
2466     @Words = split(/(\W)/, $Text);
2467    
2468     # Loop over each word
2469     foreach $Offset ( 0..scalar(@Words) ) {
2470    
2471     # Skip undefined words
2472     if ( !defined($Words[$Offset]) ) {
2473     next;
2474     }
2475    
2476     # Increment and check the summary length
2477     if ( $Words[$Offset] ne " " ) {
2478    
2479     $CurrentSummaryLength++;
2480    
2481     if ( $CurrentSummaryLength > $SummaryLength ) {
2482     # Append a diaresys at the end and bail
2483     $SummaryText .= "...";
2484     last;
2485     }
2486     }
2487    
2488     # Append the current word to the end of the summary
2489     $SummaryText .= $Words[$Offset];
2490     }
2491     }
2492     else {
2493     $SummaryText = "(Document summary unavailable)";
2494     }
2495     }
2496     elsif ( $SummaryType eq "keyword" ) {
2497    
2498     # First clean up the text
2499     if ( index($Text, "\r\n") >= 0 ) {
2500     $Text =~ s/\r//gs;
2501     }
2502     elsif ( index($Text, "\r") >= 0 ) {
2503     $Text =~ s/\r/\n/gs;
2504     }
2505     if ( defined($main::HtmlMimeTypes{$MimeType}) ) {
2506     if ( ($Index = index($Text, "\n\n")) >= 0 ) {
2507     $Text = substr($Text, $Index);
2508     }
2509     $Text =~ s/&nbsp;//gs;
2510     $Text =~ s/<.*?>//gs;
2511     }
2512     $Text =~ s/\n/ /gs;
2513     $Text =~ s/\s+/ /gs;
2514     $Text = ucfirst($Text);
2515    
2516     # Initialize our variables
2517     $OldStart = -1;
2518     $OldEnd = -1;
2519    
2520     $Start = -1;
2521     $End = -1;
2522    
2523     $CurrentSummaryLength = 0;
2524    
2525     # Reset the offset pairs and offsets
2526     undef(@OffsetPairs);
2527     undef(%Offsets);
2528    
2529    
2530     # Split the document text
2531     @Words = split(/(\W)/, $Text);
2532    
2533    
2534     # Loop over each word, checking to see if it is in the search string hash table
2535     # and build the offset list as we go along, check with the previous offset to see
2536     # if there is an overlap
2537     foreach $Offset ( 0..scalar(@Words) ) {
2538    
2539     if ( !defined($Words[$Offset]) ) {
2540     next;
2541     }
2542    
2543     # Downcase the word
2544     $Word = lc($Words[$Offset]);
2545    
2546     # Very basic plural stemming
2547     $Word =~ s/ies\Z/y/g;
2548     $Word =~ s/s\Z//g;
2549    
2550     if ( !defined($SearchStringHash{$Word}) ) {
2551     next;
2552     }
2553    
2554     $Start = ($Offset < $main::SummaryKeywordSpan) ? 0 : $Offset - $main::SummaryKeywordSpan;
2555     $End = (($Offset + $main::SummaryKeywordSpan) > (scalar(@Words) - 1)) ? (scalar(@Words) - 1) : $Offset + $main::SummaryKeywordSpan;
2556    
2557     if ( @OffsetPairs ) {
2558     ($OldStart, $OldEnd) = split(/,/, $OffsetPairs[scalar(@OffsetPairs) - 1]);
2559     }
2560    
2561     if ( $OldEnd >= $Start ) {
2562     $OffsetPairs[scalar(@OffsetPairs) - 1] = "$OldStart,$End";
2563     }
2564     else {
2565     push @OffsetPairs, "$Start,$End";
2566     }
2567     $Offsets{$Offset} = $Offset;
2568     }
2569    
2570    
2571     # Now we rebuild the sentence from the words
2572     $SummaryText = "";
2573     foreach $OffsetPair ( @OffsetPairs ) {
2574    
2575     ($Start, $End) = split(/,/, $OffsetPair);
2576    
2577     if ( $Start > 0 ) {
2578     $SummaryText .= " ...";
2579     }
2580    
2581     foreach $Offset ( $Start..$End ) {
2582    
2583     if ( !defined($Words[$Offset]) ) {
2584     next;
2585     }
2586    
2587     if ( defined($Offsets{$Offset}) ) {
2588     $SummaryText .= "<FONT COLOR=\"GREEN\">$Words[$Offset]</FONT> ";
2589     }
2590     else {
2591     $SummaryText .= $Words[$Offset] . " ";
2592     }
2593    
2594     # Increment the summary length
2595     $CurrentSummaryLength++;
2596     }
2597    
2598     # Append a diaresys at the end
2599     if ( $End < scalar(@Words) ) {
2600     $SummaryText .= "... ";
2601     }
2602    
2603     # Bail if we have reached the max summary length
2604     if ( $CurrentSummaryLength > $SummaryLength ) {
2605     last;
2606     }
2607     }
2608     }
2609     }
2610     else {
2611     undef($SummaryText);
2612     }
2613     }
2614    
2615    
2616     # Decode the headline and strip the HTML
2617     $Headline = &lDecodeURLData($Headline);
2618     $Headline =~ s/&nbsp;//gs;
2619     $Headline =~ s/<.*?>//gs;
2620     $Headline =~ s/\s+/ /gs;
2621    
2622    
2623     # Create the selector text
2624     $SelectorText = "";
2625     if ( defined($Selector) && $Selector ) {
2626     $SelectorText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2627     $SelectorText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2628     $SelectorText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2629     $SelectorText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2630     $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"Document\" VALUE=\"" . substr($SelectorText, 1) . "\"> ";
2631     }
2632    
2633    
2634     # Put up the headline, the headline becomes the link to the document
2635    
2636     # Create the link, we use the URL if it is there,
2637     # otherwise we create a link from the document ID
2638     if ( defined($URL) && ($URL ne "") ) {
2639     $LinkText = $URL;
2640     }
2641     elsif ( defined($DocumentID) && ($DocumentID ne "") ) {
2642     $LinkText = "";
2643     $LinkText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2644     $LinkText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2645     $LinkText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2646     $LinkText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2647     $LinkText = "$ScriptName/GetDocument?" . substr($LinkText, 1);
2648     }
2649     else {
2650     $LinkText = "";
2651     }
2652    
2653     # Get the mime type name
2654     $MimeTypeName = (defined($main::MimeTypeNames{$MimeType})) ? $main::MimeTypeNames{$MimeType} : $MimeType;
2655    
2656     # Put up the headline and the score, this one links to the document
2657     if ( $HTML ) {
2658     print("<!-- resultItem -->\n");
2659 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>");
2660 dpavlin 1.8 # decode some basic html from headline <b> <i>
2661     $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;
2662    
2663 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;");
2664     } else {
2665 dpavlin 1.21 printf("%3d $Headline \n", $Score);
2666 dpavlin 1.1 }
2667    
2668 dpavlin 1.5 if (0) { ## don't display description
2669 dpavlin 1.1
2670     # Put up the summary
2671     if ( defined($SummaryText) && ($SummaryText ne "") ) {
2672     if ( $HTML ) {
2673     print(" <I> $SummaryText </I><BR>\n");
2674     }
2675     else {
2676     print(" $SummaryText\n");
2677     }
2678     }
2679    
2680    
2681     # Put up the mime type name
2682     if ( ! defined($Remainder) ) {
2683     if ( $HTML ) {
2684     print("Formatttt: $MimeTypeName, ");
2685 dpavlin 1.5
2686 dpavlin 1.1 }
2687     else {
2688     print(" Format: $MimeTypeName, ");
2689     }
2690     }
2691    
2692    
2693     # Put up the date if we got it
2694 dpavlin 1.5 if ( defined($Date) && ($Date ne "") ) {
2695 dpavlin 1.1 print("Date: $Date");
2696    
2697     # Put up the time if we got it
2698 dpavlin 1.5 if ( defined($Time) && ($Time ne "") ) {
2699 dpavlin 1.1 print(" $Time");
2700     }
2701    
2702     print(", ");
2703     }
2704    
2705    
2706     # Put up the document size, remember that there is only one
2707     # item name/mime type for this document if the remainder is undefined
2708     if ( ! defined($Remainder) ) {
2709     # Put up the length if it is defined
2710     if ( defined($Length) && ($Length ne "") ) {
2711     print("Size: $Length, ");
2712     }
2713    
2714     # Put up the link
2715     if ( $HTML ) {
2716     if ( defined($URL) && ($URL ne "") ) {
2717     $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
2718     print("<A HREF=\"$URL\"> $Value </A>\n");
2719     }
2720     }
2721     else {
2722     print(" URL: $LinkText\n");
2723     }
2724    
2725     # Finish off the entry
2726     if ( $HTML ) {
2727     print("</FONT></TD></TR>");
2728     print("<!-- /resultItem -->\n");
2729     }
2730     print("\n");
2731     }
2732     else {
2733    
2734     # There is a remainder, so there is more than one item name/mime type for this document,
2735     # the item names/mime types are listed as an un-numbered list
2736     if ( $HTML ) {
2737     print("<UL>");
2738     }
2739     print("\n");
2740    
2741     # Set the last item to an empty string, this is also used as a flag
2742     $LastItemName = "";
2743    
2744     # Loop while there are item names/mime types to be parsed
2745     do {
2746    
2747     # Get the next item name/mime type if the last item is set
2748     if ( $LastItemName ne "" ) {
2749     ($ItemName, $MimeType, $URL, $Length, $Remainder) = split(/\t/, $Remainder, 5);
2750     }
2751    
2752    
2753     # If the item name has changed, so we close of the current list and start a new one
2754     if ( $ItemName ne $LastItemName ) {
2755     if ( $LastItemName ne "" ) {
2756     if ( $HTML ) {
2757     print("</UL>");
2758     }
2759     print("\n");
2760     }
2761     $Value = ucfirst($ItemName);
2762     if ( $HTML ) {
2763     print("<LI> $Value </LI>\n<UL>\n");
2764     }
2765     else {
2766     print("$Value\n");
2767     }
2768    
2769     # Set the last item name
2770     $LastItemName = $ItemName;
2771     }
2772    
2773    
2774     # Create the link, we use the URL if it is there,
2775     # otherwise we create a link from the document ID
2776     if ( defined($URL) && ($URL ne "") ) {
2777     $LinkText = $URL;
2778     }
2779     elsif ( defined($DocumentID) && ($DocumentID ne "") ) {
2780     $LinkText = "";
2781     $LinkText .= (defined($Database) && ($Database ne "")) ? "&Database=" . &lEncodeURLData($Database) : "";
2782     $LinkText .= (defined($DocumentID) && ($DocumentID ne "")) ? "&DocumentID=" . &lEncodeURLData($DocumentID) : "";
2783     $LinkText .= (defined($ItemName) && ($ItemName ne "")) ? "&ItemName=" . &lEncodeURLData($ItemName) : "";
2784     $LinkText .= (defined($MimeType) && ($MimeType ne "")) ? "&MimeType=" . &lEncodeURLData($MimeType) : "";
2785     $LinkText = "$ScriptName/GetDocument?" . substr($LinkText, 1);
2786     }
2787     else {
2788     $LinkText = "";
2789     }
2790    
2791    
2792     # Get the mime type name
2793     $MimeTypeName = defined($main::MimeTypeNames{$MimeType}) ? $main::MimeTypeNames{$MimeType} : $MimeType;
2794    
2795    
2796     # Put up the mime type, this one links to the document
2797     if ( $HTML ) {
2798     print("<LI><A HREF=\"$LinkText\" OnMouseOver=\"self.status='Retrieve this document'; return true\"> $MimeTypeName </A>");
2799     }
2800     else {
2801     print("$MimeTypeName ");
2802     }
2803    
2804     # Put up the length if it is defined
2805     if ( defined($Length) && ($Length ne "") ) {
2806     print("Size: $Length, ");
2807     }
2808    
2809     if ( $HTML ) {
2810     if ( defined($URL) && ($URL ne "") ) {
2811     $Value = (length($URL) > $main::DefaultMaxVisibleUrlLength) ? substr($URL, 0, $main::DefaultMaxVisibleUrlLength) . "..." : $URL;
2812     print("<A HREF=\"$URL\"> $Value </A>\n");
2813     }
2814     print("</LI>\n");
2815     }
2816     else {
2817     print("URL: $LinkText\n");
2818     }
2819    
2820    
2821     } while ( defined($Remainder) ); # Keep looping while there are item names/mime types to process
2822    
2823     # Close off both un-numbered lists
2824     if ( $HTML ) {
2825     print("</UL></UL>");
2826     }
2827     print("\n");
2828    
2829 dpavlin 1.5 } #if
2830 dpavlin 1.1 # Finish off the entry
2831     if ( $HTML ) {
2832     print("</FONT></TD></TR>\n");
2833     print("<!-- /resultItem -->\n");
2834     }
2835     }
2836     }
2837     }
2838    
2839    
2840     # Print up the query report if it is defined
2841     if ( defined($FinalQueryReport) && ($FinalQueryReport ne "") ) {
2842    
2843     if ( $ResultCount > 0 ) {
2844     if ( $HTML ) {
2845     print("<TR><TD COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
2846     }
2847     else {
2848     print("--------------------------------------------------------------\n\n");
2849     }
2850     }
2851    
2852     if ( $HTML ) {
2853     print("<TR><TD COLSPAN=2></TD><TD ALIGN=LEFT VALIGN=TOP>\n");
2854     }
2855    
2856     $Value = $FinalQueryReport;
2857     if ( $HTML ) {
2858     $Value =~ s/\n/\<BR\>\n/g;
2859     }
2860    
2861     if ( $HTML ) {
2862     print("<SMALL>\n");
2863     }
2864    
2865     print("$Value");
2866    
2867     if ( $HTML ) {
2868     print("</SMALL>\n");
2869     print("</TD></TR>\n");
2870     }
2871     }
2872    
2873    
2874     if ( $HTML ) {
2875    
2876     # Close off the table
2877     print("<!-- /searchResults -->\n");
2878     print("</TABLE>\n");
2879    
2880     if ( $Header ) {
2881     # Close off the form
2882     print("</FORM>\n");
2883     }
2884     }
2885    
2886     # Return the status and the query report
2887     return (1, $FinalQueryReport);
2888    
2889     }
2890    
2891    
2892    
2893     #--------------------------------------------------------------------------
2894     #
2895     # Function: vGetSearch()
2896     #
2897     # Purpose: This function displays a search form to the user
2898     #
2899     # Called by:
2900     #
2901     # Parameters: void
2902     #
2903     # Global Variables: %main::ConfigurationData, %main::FormData, $main::RemoteUser
2904     #
2905     # Returns: void
2906     #
2907     sub vGetSearch {
2908    
2909     my (@ItemList, $ItemEntry, $Flag);
2910     my ($DatabaseName, $SelectedDatabases, $Year);
2911     my ($Value, %Value);
2912    
2913    
2914     # If we are getting the default search, we check to see if there is a
2915     # user name defined and if they chose to have a default search
2916     if ( $ENV{'PATH_INFO'} eq "/GetSearch" ) {
2917    
2918     if ( defined($main::RemoteUser) && defined($main::UserSettingsFilePath) ) {
2919    
2920     # Get the default search symbol
2921     $Value = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "DefaultSearch");
2922    
2923     # Set the default search
2924     if ( defined($Value) && ($Value eq "Simple") ) {
2925     $ENV{'PATH_INFO'} = "/GetSimpleSearch";
2926     }
2927     elsif ( defined($Value) && ($Value eq "Expanded") ) {
2928     $ENV{'PATH_INFO'} = "/GetExpandedSearch";
2929     }
2930     }
2931    
2932     # Override the default search if there is field from the expanded form defined
2933     foreach $Value ('FieldContent3', 'Past', 'Since', 'Before') {
2934     if ( defined($main::FormData{$Value}) ) {
2935     $ENV{'PATH_INFO'} = "/GetExpandedSearch";
2936     last;
2937     }
2938     }
2939     }
2940    
2941    
2942    
2943     # Make sure that we send the header
2944 dpavlin 1.16 $Value = ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ? "Slo¾eno pretra¾ivanje" : "Jednostavno pretra¾ivanje";
2945 dpavlin 1.6
2946 dpavlin 1.15 &vSendHTMLHeader($Value, $main::JavaScript_SetChecked);
2947 dpavlin 1.1
2948     undef(%Value);
2949     $Value{'GetSearch'} = "GetSearch";
2950     &vSendMenuBar(%Value);
2951     undef(%Value);
2952    
2953    
2954     # Print the header ($Value is reused from the header)
2955     print("<H3>$Value:</H3>\n");
2956    
2957    
2958     # We now have a list of valid databases, at least we think so,
2959     # we check that there is at least one and put up an error message if there are none
2960     if ( scalar(keys(%main::DatabaseDescriptions)) <= 0 ) {
2961     &vHandleError("Database Search", "Sorry, there were no valid databases available for searching");
2962     goto bailFromGetSearch;
2963     }
2964    
2965    
2966    
2967     # Start the search form table
2968     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
2969    
2970     # Display the collapse and expand buttons
2971     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2>\n");
2972     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
2973    
2974     # List the hidden fields
2975     %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
2976     foreach $Value ( keys(%Value) ) {
2977     @ItemList = split(/\0/, $Value{$Value});
2978     foreach $ItemEntry ( @ItemList ) {
2979     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ItemEntry\">\n");
2980     }
2981     }
2982    
2983     if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
2984     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSimpleSearch\">\n");
2985 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");
2986 dpavlin 1.1 }
2987     else {
2988     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetExpandedSearch\">\n");
2989 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");
2990 dpavlin 1.1 }
2991     print("</FORM></TD>\n");
2992    
2993    
2994    
2995     # Send the start of the form and the buttons
2996     print("<TD ALIGN=RIGHT VALIGN=TOP>\n");
2997 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");
2998 dpavlin 1.1 print("</TD></TR>\n");
2999    
3000     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><BR></TD></TR>\n");
3001    
3002     # Send the standard fields
3003     $Value = defined($main::FormData{'Any'}) ? "VALUE='$main::FormData{'Any'}'" : "";
3004 dpavlin 1.18 print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Pretra¾i u bilo kojem polju: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"Any\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
3005 dpavlin 1.1
3006    
3007     my $nr_fields = $main::NormalSearchDropdowns;
3008     my @SearchFieldNames = @main::NormalSearchFieldNames;
3009    
3010     if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
3011     $nr_fields = $main::AdvancedSearchDropdowns;
3012     @SearchFieldNames = @main::AdvancedSearchFieldNames;
3013     }
3014    
3015     for (my $field=1; $field<= $nr_fields; $field++) {
3016    
3017 dpavlin 1.17 print "<TR>";
3018 dpavlin 1.1 if ($field == 1 ) {
3019 dpavlin 1.17 print "<TD ALIGN=LEFT VALIGN=TOP ROWSPAN=$nr_fields>";
3020 dpavlin 1.18 print "Pretra¾i u odabranom polju:";
3021 dpavlin 1.17 print "</td>";
3022 dpavlin 1.1 }
3023 dpavlin 1.17 print ("<TD ALIGN=RIGHT VALIGN=TOP>");
3024 dpavlin 1.1
3025     print ("<SELECT NAME=\"FieldName${field}\">");
3026     for (my $i=0; $i<=$#SearchFieldNames; $i++) {
3027     my $ItemEntry = $SearchFieldNames[$i];
3028 dpavlin 1.4 my $Selected = "";
3029     if ($main::FormData{"FieldName${field}"} && $main::FormData{"FieldName${field}"} eq $ItemEntry) {
3030     $Selected = "SELECTED";
3031     } elsif ($i == ($field - 1)) {
3032     $Selected = "SELECTED";
3033     }
3034    
3035 dpavlin 1.1 print("<OPTION VALUE=\"$ItemEntry\" $Selected> $main::SearchFieldDescriptions{$ItemEntry}\n");
3036     }
3037 dpavlin 1.4 my $Value = "";
3038     if (defined($main::FormData{"FieldContent${field}"})) {
3039     $Value = "VALUE='".$main::FormData{"FieldContent${field}"}."'";
3040     }
3041 dpavlin 1.17 print("</SELECT></TD><TD ALIGN=LEFT VALIGN=TOP><INPUT NAME=\"FieldContent${field}\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
3042 dpavlin 1.1 }
3043    
3044    
3045     # Send a pull-down which allows the user to select what to search for
3046     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");
3047     $Value = (defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "ADJ")) ? "SELECTED" : "";
3048     print("<OPTION VALUE=\"ADJ\"> Toènu frazu\n");
3049     $Value = ((defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "AND")) || !defined($main::FormData{'Operator'})) ? "SELECTED" : "";
3050     print("<OPTION VALUE=\"AND\" $Value> Sve rijeèi (AND)\n");
3051     $Value = (defined($main::FormData{'Operator'}) && ($main::FormData{'Operator'} eq "OR")) ? "SELECTED" : "";
3052     print("<OPTION VALUE=\"OR\" $Value> Bilo koju rijeè (OR)\n");
3053     print("</SELECT> </TD></TR>\n");
3054    
3055    
3056     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3057    
3058    
3059    
3060     # Database selection
3061     if ( %main::DatabaseDescriptions ) {
3062    
3063 dpavlin 1.18 print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Odaberite knji¾nicu èiji fond ¾elite pretra¾ivati:</TD></TR>
3064 dpavlin 1.15 <TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=4>
3065 dpavlin 1.5 ");
3066 dpavlin 1.1
3067     # Parse out the database names and put them into a
3068     # hash table, they should be separated with a '\0'
3069     undef(%Value);
3070     if ( defined($main::FormData{'Database'}) ) {
3071     @ItemList = split(/\0/, $main::FormData{'Database'});
3072     }
3073     else {
3074     $SelectedDatabases = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SelectedDatabases");
3075     if ( defined($SelectedDatabases) ) {
3076     @ItemList = split(",", $SelectedDatabases);
3077     }
3078     }
3079    
3080 dpavlin 1.7 &ShowDatabaseCheckBoxes(@ItemList);
3081 dpavlin 1.1
3082     print("</TD></TR>\n");
3083    
3084     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3085     }
3086    
3087    
3088     # Print out the RF documents
3089     if ( defined($main::FormData{'RfDocument'}) ) {
3090     print("<TR>\n");
3091     &bDisplayDocuments("Feedback Document", $main::FormData{'RfDocument'}, "RfDocument", 1, 1, 1);
3092     print("</TR>\n");
3093     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3094     }
3095    
3096    
3097     # Send complex search pull-downs
3098     if ( $ENV{'PATH_INFO'} eq "/GetExpandedSearch" ) {
3099    
3100     if ($main::ConfigurationData{'show-past-date-list'} eq 'yes') {
3101    
3102     # Send the past date list
3103     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");
3104     $Value = (!defined($main::FormData{'Past'})) ? "SELECTED" : "";
3105     print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
3106     foreach $ItemEntry ( @main::PastDate ) {
3107     $Value = (defined($main::FormData{'Past'}) && ($main::FormData{'Past'} eq $ItemEntry)) ? "SELECTED" : "";
3108     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
3109     }
3110     print("</SELECT> </TD></TR>\n");
3111     }
3112    
3113    
3114     # Send the start date
3115     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");
3116     $Value = (!defined($main::FormData{'Since'})) ? "SELECTED" : "";
3117     print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
3118    
3119     $Year = (localtime)[5] + 1900;
3120    
3121     while ( $Year >= $main::ConfigurationData{'lowest-year'} ) {
3122     $Value = (defined($main::FormData{'Since'}) && ($main::FormData{'Since'} eq $Year)) ? "SELECTED" : "";
3123     print("<OPTION VALUE=\"$Year\" $Value> $Year \n");
3124     $Year--;
3125     }
3126     print("</SELECT> </TD></TR>\n");
3127    
3128    
3129     # Send the end date
3130     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");
3131     $Value = (!defined($main::FormData{'Before'})) ? "SELECTED" : "";
3132     print("<OPTION VALUE=\"\" $Value>Bez ogranièenja...\n");
3133    
3134     $Year = (localtime)[5] + 1900;
3135    
3136     while ( $Year >= $main::ConfigurationData{'lowest-year'} ) {
3137     $Value = (defined($main::FormData{'Before'}) && ($main::FormData{'Before'} eq $Year)) ? "SELECTED" : "";
3138     print("<OPTION VALUE=\"$Year\" $Value> $Year \n");
3139     $Year--;
3140     }
3141     print("</SELECT> </TD></TR>\n");
3142    
3143     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3144     }
3145    
3146    
3147     # Send a pull-down which allows the user to select the max number of documents
3148     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Maksimalan broj rezultata pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Max\">\n");
3149    
3150     foreach $ItemEntry ( @main::MaxDocs ) {
3151     $Value = ((defined($main::FormData{'Max'}) && ($main::FormData{'Max'} eq $ItemEntry)) || (!defined($main::FormData{'Max'}) && ($ItemEntry eq $main::DefaultMaxDoc)) ) ? "SELECTED" : "";
3152     if ( ($ItemEntry >= 500) && $ENV{'PATH_INFO'} ne "/GetExpandedSearch" ) {
3153     next;
3154     }
3155     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
3156     }
3157    
3158     print("</SELECT> </TD></TR>\n");
3159    
3160    
3161     # Send a pull-down which allows the user to select the sort order
3162     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Sortiranje rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"Order\">\n");
3163     # print("<OPTION VALUE=\"\"> Relevance\n");
3164     $Value = (defined($main::FormData{'Order'}) && ($main::FormData{'Order'} eq "SORT:DATE:DESC")) ? "SELECTED" : "";
3165     print("<OPTION VALUE=\"SORT:DATE:DESC\" $Value> Datum - najprije novije\n");
3166     $Value = (defined($main::FormData{'Order'}) && ($main::FormData{'Order'} eq "DATEASCSORT")) ? "SELECTED" : "";
3167     print("<OPTION VALUE=\"SORT:DATE:ASC\" $Value> Datum - najprije starije\n");
3168 dpavlin 1.9 ### FIX:: SORT
3169     # print("<OPTION VALUE=\"SORT:700+:DESC\"> autor\n");
3170     # print("<OPTION VALUE=\"SORT:200+:DESC\"> naslov\n");
3171 dpavlin 1.1 print("</SELECT> </TD></TR>\n");
3172    
3173    
3174     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3175     print("<TR><TD ALIGN=RIGHT COLSPAN=3><INPUT TYPE=SUBMIT VALUE=\"Pretra¾i bazu\"> <INPUT TYPE=RESET VALUE=\"Pobri¹i polja\"></TD></TR>\n");
3176    
3177     print("</FORM>\n");
3178     print("</TABLE>\n");
3179    
3180    
3181     # Bail from the search
3182     bailFromGetSearch:
3183    
3184     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3185     undef(%Value);
3186     $Value{'GetSearch'} = "GetSearch";
3187     &vSendMenuBar(%Value);
3188     undef(%Value);
3189    
3190     &vSendHTMLFooter;
3191    
3192     return;
3193    
3194     }
3195    
3196    
3197    
3198    
3199    
3200    
3201     #--------------------------------------------------------------------------
3202     #
3203     # Function: vGetSearchResults()
3204     #
3205     # Purpose: This function run the search and displays the results to the user
3206     #
3207     # Called by:
3208     #
3209     # Parameters: void
3210     #
3211     # Global Variables: %main::ConfigurationData, %main::FormData, $main::RemoteUser
3212     #
3213     # Returns: void
3214     #
3215     sub vGetSearchResults {
3216    
3217     my (%Databases, $Databases, $SearchString, $SearchAndRfDocumentURL, $RfText);
3218     my ($Status, $DocumentText, $SearchResults, $QueryReport, $ErrorNumber, $ErrorMessage);
3219     my ($DatabaseRelevanceFeedbackFilterKey, $DatabaseRelevanceFeedbackFilterFunction);
3220     my (@Values, %Value, $Value);
3221    
3222    
3223    
3224     # Check to see if there are any documents selected, if there are, they need
3225     # to be converted to RF documents before we put up the header, this is because
3226     # the header creates a search link from existing search fields, we also deduplicate
3227     # documents along the way
3228     if ( defined($main::FormData{'RfDocument'}) || defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) {
3229    
3230     # Undefine the hash table in preparation
3231     undef(%Value);
3232    
3233     # Make a hash table from the documents already selected for feedback
3234     if ( defined($main::FormData{'RfDocument'}) ) {
3235     foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
3236     $Value{$Value} = $Value;
3237     }
3238     }
3239    
3240     # Add document that were specifically selected
3241     if ( defined($main::FormData{'Document'}) ) {
3242     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
3243     $Value{$Value} = $Value;
3244     }
3245     }
3246     # Otherwise add documents that were selected by default
3247     elsif ( defined($main::FormData{'Documents'}) ) {
3248     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
3249     $Value{$Value} = $Value;
3250     }
3251     }
3252    
3253     # Assemble the new content
3254     $main::FormData{'RfDocument'} = join("\0", keys(%Value));
3255    
3256     # Delete the old content
3257     delete($main::FormData{'Document'});
3258     delete($main::FormData{'Documents'});
3259     }
3260    
3261    
3262     # Set the database names if needed
3263     if ( !defined($main::FormData{'Database'}) && defined($main::FormData{'RfDocument'}) ) {
3264    
3265     # Loop over each entry in the documents list
3266     foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
3267    
3268     # Parse out the document entry
3269     %Value = &hParseURLIntoHashTable($Value);
3270    
3271     # Add the database name to the hash table
3272     $Databases{$Value{'Database'}} = $Value{'Database'};
3273     }
3274    
3275     $main::FormData{'Database'} = join("\0", keys(%Databases));
3276     }
3277    
3278    
3279    
3280     # Make sure that we send the header
3281     &vSendHTMLHeader("Rezultati pretra¾ivanja", undef);
3282     undef(%Value);
3283     &vSendMenuBar(%Value);
3284    
3285    
3286     # Check that at least one database was selected
3287     if ( !defined($main::FormData{'Database'}) ) {
3288 dpavlin 1.18 print("<H3>Pretra¾ivanje baza:</H3>\n");
3289     print("<H3><CENTER>Niste odabrali knji¾nicu koju ¾elite pretra¾ivati.</CENTER></H3>\n");
3290 dpavlin 1.1 print("<P>\n");
3291 dpavlin 1.18 print("Potrebno je da barem jedna knji¾nica bude odabrana, kako biste mogli pretra¾ivati.\n");
3292     print("Kliknite na <B>'back'</B> u svom browseru, odaberite barem jednu knji¾nicu i poku¹ajte ponovo.\n");
3293 dpavlin 1.1 goto bailFromGetSearchResults;
3294     }
3295    
3296    
3297    
3298     # Extract the search information
3299     foreach $Value ( 1..100 ) {
3300    
3301     my ($FieldName) = "FieldName" . $Value;
3302     my ($FieldContent) = "FieldContent" . $Value;
3303    
3304     if ( defined($main::FormData{$FieldName}) ) {
3305     if ( defined($main::FormData{$FieldContent}) && ($main::FormData{$FieldContent} ne "") ) {
3306     $main::FormData{$main::FormData{$FieldName}} = $main::FormData{$FieldContent};
3307     }
3308     }
3309     }
3310    
3311    
3312    
3313     # Set the local database names
3314     if ( defined($main::FormData{'Database'}) ) {
3315     $Databases = $main::FormData{'Database'};
3316     }
3317    
3318    
3319     # Convert all the '\0' to ','
3320     $Databases =~ tr/\0/,/;
3321    
3322    
3323     # Add the max doc restriction
3324     if ( !defined($main::FormData{'Max'}) ) {
3325     $main::FormData{'Max'} = $main::DefaultMaxDoc;
3326     }
3327    
3328    
3329     # Generate the search string
3330     $SearchString = &sMakeSearchString(%main::FormData);
3331    
3332     # Retrieve the relevance feedback documents
3333     if ( defined($main::FormData{'RfDocument'}) ) {
3334    
3335     $RfText = "";
3336    
3337     # Loop over each entry in the documents list
3338     foreach $Value ( split(/\0/, $main::FormData{'RfDocument'}) ) {
3339    
3340     # Parse out the document entry
3341     %Value = &hParseURLIntoHashTable($Value);
3342    
3343     # Check this document can be used for relevance feedback
3344     if ( !defined($main::RFMimeTypes{$Value{'MimeType'}}) ) {
3345     next;
3346     }
3347    
3348     # Get the document
3349     ($Status, $DocumentText) = MPS::GetDocument($main::MPSSession, $Value{'Database'}, $Value{'DocumentID'}, $Value{'ItemName'}, $Value{'MimeType'});
3350    
3351     if ( $Status ) {
3352    
3353     $DatabaseRelevanceFeedbackFilterKey = "$main::DatabaseRelevanceFeedbackFilter:$Value{'Database'}:$Value{'ItemName'}:$Value{'MimeType'}";
3354    
3355     # Is a filter defined for this database relevance feedback filter key ?
3356     if ( defined($main::DatabaseFilters{$DatabaseRelevanceFeedbackFilterKey}) ) {
3357    
3358     # Pull in the package
3359     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Value{'Database'}"};
3360    
3361     # Filter the document
3362     $Value = $main::DatabaseFilters{$DatabaseRelevanceFeedbackFilterKey};
3363     $DatabaseRelevanceFeedbackFilterFunction = \&$Value;
3364     $DocumentText = $DatabaseRelevanceFeedbackFilterFunction->($Value{'Database'}, $Value{'DocumentID'}, $Value{'ItemName'}, $Value{'MimeType'}, $DocumentText);
3365    
3366     }
3367     else {
3368    
3369     # Strip the HTML from the text (this is only really useful on HTML documents)
3370     if ( defined($main::HtmlMimeTypes{$Value{'MimeType'}}) ) {
3371     $DocumentText =~ s/&nbsp;//gs;
3372     $DocumentText =~ s/<.*?>//gs;
3373     }
3374     }
3375    
3376     $RfText .= $DocumentText . " ";
3377     }
3378     }
3379     }
3380    
3381    
3382     # Run the search
3383     ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Databases, $SearchString, $RfText, 0, $main::FormData{'Max'} - 1, $main::ConfigurationData{'max-score'});
3384    
3385     if ( $Status ) {
3386    
3387     # Display the search results and get the query report text
3388     ($Status, $QueryReport) = &bsDisplaySearchResults("Rezultati pretra¾ivanja:", undef, undef, undef, $SearchResults, undef, $ENV{'SCRIPT_NAME'}, 1, 1, 1, %main::FormData);
3389    
3390     # Save the search history
3391     if ( defined($main::RemoteUser) ) {
3392    
3393     # Generate the search string
3394     $SearchAndRfDocumentURL = &sMakeSearchAndRfDocumentURL(%main::FormData);
3395    
3396     # Save the search history
3397     &iSaveSearchHistory(undef, $SearchAndRfDocumentURL, $SearchResults, $QueryReport);
3398    
3399     # Purge the search history files
3400     &vPurgeSearchHistory;
3401     }
3402     }
3403     else {
3404     ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
3405     &vHandleError("Database Search", "Sorry, failed to search the database(s)");
3406     print("The following error message was reported: <BR>\n");
3407     print("Error Message: $ErrorMessage <BR>\n");
3408     print("Error Number: $ErrorNumber <BR>\n");
3409     goto bailFromGetSearchResults;
3410     }
3411    
3412    
3413     # Bail from the search
3414     bailFromGetSearchResults:
3415    
3416     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3417     undef(%Value);
3418     &vSendMenuBar(%Value);
3419    
3420     &vSendHTMLFooter;
3421    
3422     return;
3423    
3424     }
3425    
3426    
3427    
3428    
3429    
3430    
3431     #--------------------------------------------------------------------------
3432     #
3433     # Function: vGetDatabaseInfo()
3434     #
3435     # Purpose: This function allows the user to get some database information
3436     # such as the description, the contents and the time period spanned
3437     # by the content.
3438     #
3439     # Called by:
3440     #
3441     # Parameters: void
3442     #
3443     # Global Variables: %main::ConfigurationData, %main::FormData
3444     #
3445     # Returns: void
3446     #
3447     sub vGetDatabaseInfo {
3448    
3449     my ($DatabaseDescription, $DatabaseLanguage, $DatabaseTokenizer, $DocumentCount, $TotalWordCount, $UniqueWordCount, $StopWordCount, $AccessControl, $UpdateFrequency, $LastUpdateDate, $LastUpdateTime, $CaseSensitive);
3450     my ($FieldInformation, $FieldName, $FieldDescription);
3451     my ($Status, $Text, $Time, $Title);
3452     my ($ErrorNumber, $ErrorMessage);
3453     my ($Value, %Value);
3454    
3455    
3456    
3457     # Check we that we got a database name
3458     if ( !defined($main::FormData{'Database'}) ) {
3459     &vHandleError("Database information", "Sorry, the database content description could not be obtained");
3460     goto bailFromGetDatabaseInfo;
3461     }
3462    
3463    
3464     # Make sure that we send the header
3465     $Title = "Database Information: " . (defined($main::DatabaseDescriptions{$main::FormData{'Database'}})
3466     ? $main::DatabaseDescriptions{$main::FormData{'Database'}} : "");
3467     &vSendHTMLHeader($Title, undef);
3468     undef(%Value);
3469     &vSendMenuBar(%Value);
3470    
3471    
3472     # Get the database information
3473     ($Status, $Text) = MPS::GetDatabaseInfo($main::MPSSession, $main::FormData{'Database'});
3474    
3475     if ( $Status ) {
3476    
3477     # Display the database information
3478     print("<H3>Database information:</H3>\n");
3479    
3480     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
3481    
3482    
3483     # Send the database description
3484     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");
3485     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3486    
3487     # Truncate the line
3488     chop ($Text);
3489    
3490     # Parse the database information
3491     ($DatabaseDescription, $DatabaseLanguage, $DatabaseTokenizer, $DocumentCount, $TotalWordCount, $UniqueWordCount, $StopWordCount, $AccessControl, $UpdateFrequency, $LastUpdateDate, $LastUpdateTime, $CaseSensitive) = split(/\t/, $Text);
3492    
3493     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");
3494     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Total number of words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $TotalWordCount </TD></TR>\n");
3495     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Number of unique words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $UniqueWordCount </TD></TR>\n");
3496     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Number of stop words: </TD> <TD ALIGN=LEFT VALIGN=TOP> $StopWordCount </TD></TR>\n");
3497    
3498     # Get the time of last update of the data directory
3499     # $Time = (stat("$main::ConfigurationData{'data-directory'}/$main::FormData{'Database'}/"))[9];
3500     # $Value = &sGetPrintableDateFromTime($Time);
3501     # print("<TR><TD ALIGN=LEFT VALIGN=TOP> Data last updated on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
3502    
3503     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Index last updated on: </TD> <TD ALIGN=LEFT VALIGN=TOP> $LastUpdateDate ($LastUpdateTime) </TD></TR>\n");
3504    
3505     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
3506    
3507     # Get the database field information
3508     ($Status, $Text) = MPS::GetDatabaseFieldInfo($main::MPSSession, $main::FormData{'Database'});
3509    
3510     if ( $Status ) {
3511     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");
3512    
3513     foreach $FieldInformation ( split(/\n/, $Text) ) {
3514     ($FieldName, $FieldDescription, $Value) = split(/\t/, $FieldInformation, 3);
3515     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> $FieldName </TD> <TD ALIGN=LEFT VALIGN=TOP> $FieldDescription </TD></TR>\n");
3516     }
3517     }
3518    
3519     print("</TABLE>\n");
3520    
3521     }
3522     else {
3523     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Text, 2);
3524     &vHandleError("Database information", "Sorry, failed to get the database information");
3525     print("The following error message was reported: <BR>\n");
3526     print("Error Message: $ErrorMessage <BR>\n");
3527     print("Error Number: $ErrorNumber <BR>\n");
3528     goto bailFromGetDatabaseInfo;
3529     }
3530    
3531    
3532    
3533     # Bail from the database info
3534     bailFromGetDatabaseInfo:
3535    
3536     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3537     undef(%Value);
3538     &vSendMenuBar(%Value);
3539    
3540     &vSendHTMLFooter;
3541    
3542     return;
3543    
3544     }
3545    
3546    
3547    
3548    
3549    
3550    
3551     #--------------------------------------------------------------------------
3552     #
3553     # Function: vGetDocument()
3554     #
3555     # Purpose: This function get a document from the database.
3556     #
3557     # Called by:
3558     #
3559     # Parameters: void
3560     #
3561     # Global Variables: %main::ConfigurationData, %main::FormData,
3562     # $main::FooterSent
3563     #
3564     # Returns: void
3565     #
3566     sub vGetDocument {
3567    
3568     my (@DocumentList, %Document, $Document, $TextDocumentFlag);
3569     my ($Status, $Data, $ErrorNumber, $ErrorMessage);
3570     my (%QualifiedDocumentFolders, $QualifiedDocumentFolders, $FolderName, $DocumentFolderEntry);
3571     my ($DatabaseDocumentFilterFunction, $DatabaseDocumentFilterKey);
3572     my ($SelectorText, $FilteredData, $SimilarDocuments, $SearchResults);
3573     my (%Value, $Value);
3574    
3575    
3576    
3577     # Assemble the documents selected into a list do that we keep their order
3578     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) || defined($main::FormData{'DocumentID'}) ) {
3579    
3580     # Undefine the hash table in preparation
3581     undef(%Value);
3582    
3583     # Add document that were specifically selected
3584     if ( defined($main::FormData{'Document'}) ) {
3585     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
3586     if ( !defined($Value{$Value}) ) {
3587     push @DocumentList, $Value;
3588     $Value{$Value} = $Value;
3589     }
3590     }
3591     }
3592     # Otherwise add documents that were selected by default
3593     elsif ( defined($main::FormData{'Documents'}) ) {
3594     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
3595     if ( !defined($Value{$Value}) ) {
3596     push @DocumentList, $Value;
3597     $Value{$Value} = $Value;
3598     }
3599     }
3600     }
3601    
3602     # Add document from the URL
3603     if ( defined($main::FormData{'DocumentID'}) ) {
3604     $Value = "";
3605     $Value .= (defined($main::FormData{'Database'}) && ($main::FormData{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($main::FormData{'Database'}) : "";
3606     $Value .= (defined($main::FormData{'DocumentID'}) && ($main::FormData{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($main::FormData{'DocumentID'}) : "";
3607     $Value .= (defined($main::FormData{'ItemName'}) && ($main::FormData{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($main::FormData{'ItemName'}) : "";
3608     $Value .= (defined($main::FormData{'MimeType'}) && ($main::FormData{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($main::FormData{'MimeType'}) : "";
3609     if ( !defined($Value{$Value}) ) {
3610     push @DocumentList, $Value;
3611     $Value{$Value} = $Value;
3612     }
3613     }
3614     }
3615    
3616    
3617    
3618     # Catch no document selection
3619     if ( !@DocumentList || (scalar(@DocumentList) == 0) ) {
3620    
3621     # Make sure that we send the header
3622     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3623     &vSendHTMLHeader("Similar Documents", undef);
3624     }
3625     else {
3626     &vSendHTMLHeader("Documents", undef);
3627     }
3628     undef(%Value);
3629     &vSendMenuBar(%Value);
3630    
3631     print("<H3>Document retrieval:</H3>\n");
3632     print("<H3><CENTER>Sorry, no document(s) were selected for retrieval.</CENTER></H3>\n");
3633     print("<P>\n");
3634     print("There needs to be a least one document selected in order to perform the retrieval.\n");
3635     print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
3636     goto bailFromGetDocument;
3637     }
3638    
3639    
3640    
3641     # Set the text document flag
3642     $TextDocumentFlag = 0;
3643    
3644     # Check the documents for text based documents
3645     foreach $Document ( @DocumentList ) {
3646    
3647     # Parse out the document entry
3648     %Document = &hParseURLIntoHashTable($Document);
3649    
3650     # Set the text flag if there are any text documents in the list
3651     if ( $Document{'MimeType'} =~ /^text\// ) {
3652     $TextDocumentFlag = 1;
3653     }
3654     }
3655    
3656    
3657    
3658     # If there were no text documents in our list, we display the first document in the
3659     # list, this is to handle cases where got one or more non-text documents (such as
3660     # images, pdf files, etc)
3661     if ( ! $TextDocumentFlag ) {
3662    
3663     %Document = &hParseURLIntoHashTable($DocumentList[0]);
3664    
3665     # Get the document
3666     ($Status, $Data) = MPS::GetDocument($main::MPSSession, $Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'});
3667    
3668     if ( !$Status ) {
3669    
3670     # Make sure that we send the header
3671     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3672     &vSendHTMLHeader("Similar Documents", undef);
3673     }
3674     else {
3675     &vSendHTMLHeader("Documents", undef);
3676     }
3677     undef(%Value);
3678     &vSendMenuBar(%Value);
3679    
3680     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Data, 2);
3681     # The database document could not be gotten, so we inform the user of the fact
3682     &vHandleError("Document retrieval", "Sorry, the database document could not be obtained");
3683     print("The following error message was reported: <BR>\n");
3684     print("Error Message: $ErrorMessage <BR>\n");
3685     print("Error Number: $ErrorNumber <BR>\n");
3686     goto bailFromGetDocument;
3687     }
3688    
3689     # Send the content type
3690     print("Content-type: $Document{'MimeType'}\n\n");
3691    
3692     # Send the document
3693     print("$Data");
3694    
3695     return;
3696     }
3697    
3698    
3699    
3700     # Make sure that we send the header
3701     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3702     &vSendHTMLHeader("Similar Documents", undef);
3703     }
3704     else {
3705     &vSendHTMLHeader("Documents", undef);
3706     }
3707     undef(%Value);
3708     &vSendMenuBar(%Value);
3709    
3710    
3711    
3712     # Print the header
3713     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3714     print("<H3>Similar Documents:</H3>\n");
3715     }
3716     else {
3717     print("<H3>Dokumenti:</H3>\n");
3718     }
3719    
3720    
3721     # Start the form
3722     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
3723    
3724     # Send the pull-down
3725     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
3726     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");
3727    
3728     if ( defined($main::RemoteUser) ) {
3729     print("<SELECT NAME=\"Action\">\n");
3730     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3731     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultate\n");
3732     }
3733     if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
3734     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
3735     }
3736     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
3737     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
3738     }
3739     print("<OPTION VALUE=\"GetSaveFolder\">Save selected documents to a new document folder\n");
3740    
3741     # Get the document folder hash
3742     %QualifiedDocumentFolders = &hGetDocumentFolders;
3743    
3744     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
3745    
3746     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
3747    
3748     # Get the document folder file name and encode it
3749     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
3750     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
3751    
3752     print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry\">Add selected documents to the '$FolderName' document folder\n");
3753     }
3754    
3755     print("</SELECT>\n");
3756     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
3757     }
3758     else {
3759     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
3760     print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetSearchResults\">\n");
3761     print("<INPUT TYPE=SUBMIT VALUE=\"Run search with documents as relevance feedback\">\n");
3762     }
3763     }
3764    
3765     print("</TD></TR>\n");
3766     print("</TABLE>\n");
3767    
3768    
3769     # Display the documents
3770    
3771     print("<TABLE BORDER=0 CELLPADDING=3 CELLSPACING=0 WIDTH=100%>\n");
3772    
3773    
3774     # Display the selector for all the documents
3775     $SelectorText = "";
3776    
3777     foreach $Document ( @DocumentList ) {
3778    
3779     # Parse out the document entry
3780     %Document = &hParseURLIntoHashTable($Document);
3781    
3782     # Skip non-text documents
3783     if ( !($Document{'MimeType'} =~ /^text\//) ) {
3784     next;
3785     }
3786    
3787     $Value = "";
3788     $Value .= (defined($Document{'Database'}) && ($Document{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Document{'Database'}) : "";
3789     $Value .= (defined($Document{'DocumentID'}) && ($Document{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Document{'DocumentID'}) : "";
3790     $Value .= (defined($Document{'ItemName'}) && ($Document{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($Document{'ItemName'}) : "";
3791     $Value .= (defined($Document{'MimeType'}) && ($Document{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($Document{'MimeType'}) : "";
3792     $SelectorText .= (($SelectorText ne "") ? "|" : "") . substr($Value, 1);
3793     }
3794    
3795     $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
3796     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> $SelectorText </TD></TR>\n");
3797    
3798    
3799    
3800     # Get the similar documents value
3801     if ( defined($main::RemoteUser) ) {
3802     $SimilarDocuments = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SimilarDocuments");
3803     }
3804     else {
3805     $SimilarDocuments = $main::DefaultSimilarDocument;
3806     }
3807    
3808    
3809    
3810     foreach $Document ( @DocumentList ) {
3811    
3812     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3> <HR WIDTH=50%> </TD></TR>\n");
3813    
3814    
3815     # Parse out the document entry
3816     %Document = &hParseURLIntoHashTable($Document);
3817    
3818     # Skip non-text documents
3819     if ( !($Document{'MimeType'} =~ /^text\//) ) {
3820     next;
3821     }
3822    
3823    
3824     # Get the document
3825     ($Status, $Data) = MPS::GetDocument($main::MPSSession, $Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'});
3826    
3827     if ( !$Status ) {
3828     ($ErrorNumber, $ErrorMessage) = split(/\t/, $Data, 2);
3829     # The database document could not be gotten, so we inform the user of the fact
3830     &vHandleError("Document retrieval", "Sorry, the database document could not be obtained");
3831     print("The following error message was reported: <BR>\n");
3832     print("Error Message: $ErrorMessage <BR>\n");
3833     print("Error Number: $ErrorNumber <BR>\n");
3834     goto bailFromGetDocument;
3835     }
3836    
3837    
3838     # Create the database document filter key
3839     $DatabaseDocumentFilterKey = "$main::DatabaseDocumentFilter:$Document{'Database'}:$Document{'ItemName'}:$Document{'MimeType'}";
3840    
3841     # Is a filter defined for this database document filter key ?
3842     if ( defined($main::DatabaseFilters{$DatabaseDocumentFilterKey}) ) {
3843    
3844     # Pull in the package
3845     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Document{'Database'}"};
3846    
3847     # Filter the document
3848     $Value = $main::DatabaseFilters{$DatabaseDocumentFilterKey};
3849     $DatabaseDocumentFilterFunction = \&$Value;
3850     $FilteredData = $DatabaseDocumentFilterFunction->($Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'}, $Data);
3851     } else {
3852     # use default filter key
3853    
3854     # Pull in the package
3855     require $main::DatabaseFilters{"$main::DatabaseFiltersPackage:default"};
3856    
3857     # Filter the document
3858     $Value = $main::DatabaseFilters{"$main::DatabaseDocumentFilter:default:$Document{'ItemName'}:$Document{'MimeType'}"};
3859     $DatabaseDocumentFilterFunction = \&$Value;
3860     $FilteredData = $DatabaseDocumentFilterFunction->($Document{'Database'}, $Document{'DocumentID'}, $Document{'ItemName'}, $Document{'MimeType'}, $Data);
3861     }
3862    
3863    
3864    
3865     # Create the document selector button text
3866     $SelectorText = "";
3867     $SelectorText .= (defined($Document{'Database'}) && ($Document{'Database'} ne "")) ? "&Database=" . &lEncodeURLData($Document{'Database'}) : "";
3868     $SelectorText .= (defined($Document{'DocumentID'}) && ($Document{'DocumentID'} ne "")) ? "&DocumentID=" . &lEncodeURLData($Document{'DocumentID'}) : "";
3869     $SelectorText .= (defined($Document{'ItemName'}) && ($Document{'ItemName'} ne "")) ? "&ItemName=" . &lEncodeURLData($Document{'ItemName'}) : "";
3870     $SelectorText .= (defined($Document{'MimeType'}) && ($Document{'MimeType'} ne "")) ? "&MimeType=" . &lEncodeURLData($Document{'MimeType'}) : "";
3871     $SelectorText = "<INPUT TYPE=\"checkbox\" NAME=\"Document\" VALUE=\"" . substr($SelectorText, 1) . "\"> ";
3872    
3873    
3874     # Send the document text
3875     print("<TR><TD ALIGN=LEFT VALIGN=TOP> $SelectorText </TD> <TD ALIGN=LEFT VALIGN=TOP>$FilteredData</TD></TR>");
3876     if ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
3877    
3878     # Get the similar documents if needed
3879     if ( defined($main::ConfigurationData{'allow-similiar-search'}) && ($main::ConfigurationData{'allow-similiar-search'} eq "yes") &&
3880     defined($SimilarDocuments) ) {
3881    
3882     # Run the search, discard the query report
3883     ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Document{'Database'}, "{NOREPORT}", $Data, 0, $SimilarDocuments - 1, $main::ConfigurationData{'max-score'});
3884    
3885     if ( $Status ) {
3886    
3887     # Display the search result
3888     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3> <HR WIDTH=25%> </TD></TR>\n");
3889     print("<TR><TD ALIGN=LEFT VALIGN=TOP></TD> <TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> \n");
3890     print("<B>Similar Documents:</B>\n");
3891     ($Status, undef) = &bsDisplaySearchResults("Similar Documents:", undef, undef, undef, $SearchResults, undef, $ENV{'SCRIPT_NAME'}, 0, 1, 1, %main::FormData);
3892     print("</TD></TR>\n");
3893     }
3894     else {
3895     ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
3896     &vHandleError("Database Search", "Sorry, failed to search the database(s)");
3897     print("The following error message was reported: <BR>\n");
3898     print("Error Message: $ErrorMessage <BR>\n");
3899     print("Error Number: $ErrorNumber <BR>\n");
3900     goto bailFromGetDocument;
3901     }
3902     }
3903     }
3904     }
3905    
3906    
3907     # Close off the form
3908     print("</FORM>\n");
3909    
3910     # Close off the table
3911     print("</TABLE>\n");
3912    
3913    
3914     # Bail from getting the document
3915     bailFromGetDocument:
3916    
3917     print("<CENTER><HR WIDTH=50%></CENTER>\n");
3918     undef(%Value);
3919     &vSendMenuBar(%Value);
3920    
3921     &vSendHTMLFooter;
3922    
3923     return;
3924    
3925     }
3926    
3927    
3928    
3929    
3930    
3931    
3932     #--------------------------------------------------------------------------
3933     #
3934     # Function: vGetUserSettings()
3935     #
3936     # Purpose: This function displays a user settings form to the user
3937     #
3938     # Called by:
3939     #
3940     # Parameters: void
3941     #
3942     # Global Variables: %main::ConfigurationData, %main::FormData,
3943     # $main::UserSettingsFilePath, $main::RemoteUser,
3944     #
3945     # Returns: void
3946     #
3947     sub vGetUserSettings {
3948    
3949     my ($UserName, $SearchHistory, $DefaultSearch, $SelectedDatabases, $EmailAddress, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SummaryType, $SummaryLength, $SimilarDocuments);
3950     my ($SearchHistoryCount, $HeaderName);
3951     my ($DatabaseName, @ItemList, $ItemEntry, $Flag);
3952     my ($Value, %Value);
3953    
3954    
3955     # Return an error if the remote user name/account directory is not defined
3956     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
3957     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
3958     &vSendHTMLFooter;
3959     return;
3960     }
3961    
3962    
3963    
3964     # Make sure that we send the header
3965 dpavlin 1.15 &vSendHTMLHeader("My Settings", $main::JavaScript_SetChecked);
3966 dpavlin 1.1 undef(%Value);
3967     $Value{'GetUserSettings'} = "GetUserSettings";
3968     &vSendMenuBar(%Value);
3969     undef(%Value);
3970    
3971    
3972    
3973     # Get information from the XML saved search file
3974     ($HeaderName, %Value) = &shGetHashFromXMLFile($main::UserSettingsFilePath);
3975    
3976     # Check the header if it is defines, delete the file if it is not valid,
3977     # else set the variables from the hash table contents
3978     if ( defined($HeaderName) ) {
3979     if ( $HeaderName ne "UserSettings" ) {
3980     unlink($main::UserSettingsFilePath);
3981     }
3982     else {
3983     $UserName = $Value{'UserName'};
3984     $SearchHistory = $Value{'SearchHistory'};
3985     $DefaultSearch = $Value{'DefaultSearch'};
3986     $SelectedDatabases = $Value{'SelectedDatabases'};
3987     $EmailAddress = $Value{'EmailAddress'};
3988     $SearchFrequency = $Value{'SearchFrequency'};
3989     $DeliveryFormat = $Value{'DeliveryFormat'};
3990     $DeliveryMethod = $Value{'DeliveryMethod'};
3991     $SummaryType = $Value{'SummaryType'};
3992     $SummaryLength = $Value{'SummaryLength'};
3993     $SimilarDocuments = $Value{'SimilarDocuments'};
3994     }
3995     }
3996    
3997    
3998     # Give the user a form to fill out
3999    
4000     print("<H3> Postavke: </H3>\n");
4001    
4002     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
4003 dpavlin 1.15 print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetUserSettings\" NAME=\"Search\" METHOD=POST>\n");
4004 dpavlin 1.1
4005     # Send the buttons
4006     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");
4007    
4008    
4009    
4010     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4011    
4012     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Informacije o korisniku: </B> </TR>\n");
4013    
4014     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Login: </TD><TD ALIGN=LEFT VALIGN=TOP> $ENV{'REMOTE_USER'} </TD></TR>\n");
4015    
4016     $Value = (defined($UserName)) ? "VALUE=\"$UserName\"" : "";
4017     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");
4018    
4019     # Are regular searches enabled?
4020     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4021    
4022     # Get the email address
4023     $Value = (defined($EmailAddress)) ? "VALUE=\"$EmailAddress\"" : "";
4024     print("<TR><TD ALIGN=LEFT VALIGN=TOP> E-mail adresa:");
4025     if ( !defined($EmailAddress) && defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4026     print(" (*) ");
4027     }
4028     print(": </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"EmailAddress\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
4029    
4030     if ( !defined($EmailAddress) && defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4031     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");
4032     }
4033     }
4034    
4035    
4036     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4037    
4038     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Search Preferences: </B> </TD></TR>\n");
4039    
4040     # Send a pull-down which allows the user to select which search form to default to
4041     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Forma za pretra¾ivanje: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DefaultSearch\">\n");
4042     $Value = (defined($DefaultSearch) && ($DefaultSearch eq "Simple")) ? "SELECTED" : "";
4043     print("<OPTION VALUE=\"Simple\" $Value> Jednostavna forma za pretra¾ivanje\n");
4044     $Value = (defined($DefaultSearch) && ($DefaultSearch eq "Expanded")) ? "SELECTED" : "";
4045     print("<OPTION VALUE=\"Expanded\" $Value>Forma za pretra¾ivanje s vi¹e kriterija\n");
4046     print("</SELECT> </TD></TR>\n");
4047    
4048     # Send a pull-down which allows the user to select how many previous searches to store
4049     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");
4050    
4051     for ( $SearchHistoryCount = 5; $SearchHistoryCount <= 20; $SearchHistoryCount += 5 ) {
4052     $Value = (defined($SearchHistory) && ($SearchHistory == $SearchHistoryCount)) ? "SELECTED" : "";
4053     print("<OPTION VALUE=\"$SearchHistoryCount\" $Value> $SearchHistoryCount \n");
4054     }
4055     print("</SELECT> </TD></TR>\n");
4056    
4057    
4058     # Database selection preferences
4059     if ( %main::DatabaseDescriptions ) {
4060    
4061     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4062    
4063     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Odabrane baze: </B> </TD></TR>\n");
4064    
4065 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");
4066 dpavlin 1.1
4067     # Parse out the database names and put them into a
4068     # hash table, they should be separated with a '\n'
4069     if ( defined($SelectedDatabases) && ($SelectedDatabases ne "") ) {
4070     @ItemList = split(",", $SelectedDatabases);
4071     }
4072 dpavlin 1.15
4073 dpavlin 1.7 &ShowDatabaseCheckBoxes(@ItemList);
4074    
4075 dpavlin 1.1 print("</TD></TR>\n");
4076     }
4077    
4078    
4079    
4080     # Send a pull-down which allows the user to select whether to display summaries or not, and how long we want them
4081     if ( defined($main::ConfigurationData{'allow-summary-displays'}) && ($main::ConfigurationData{'allow-summary-displays'} eq "yes") ) {
4082    
4083     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4084    
4085     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Document Summary Preferences: </B> </TD></TR>\n");
4086    
4087     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Document summary type: </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SummaryType\">\n");
4088     foreach $ItemEntry ( keys (%main::SummaryTypes) ) {
4089     $Value = (defined($SummaryType) && ($SummaryType eq $ItemEntry)) ? "SELECTED" : "";
4090     print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::SummaryTypes{$ItemEntry}\n");
4091     }
4092     print("</SELECT></TD></TR>\n");
4093    
4094     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Document summary length in words (max): </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SummaryLength\">\n");
4095     foreach $ItemEntry ( @main::SummaryLengths ) {
4096     $Value = (defined($SummaryLength) && ($SummaryLength eq $ItemEntry)) ? "SELECTED" : "";
4097     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
4098     }
4099     print("</SELECT></TD></TR>\n");
4100     }
4101    
4102    
4103     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4104    
4105     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Document Retrieval Preferences: </B> </TD></TR>\n");
4106    
4107     # Send a pull-down which allows the user to select whether to display summaries or not, and how long we want them
4108     if ( defined($main::ConfigurationData{'allow-similiar-search'}) && ($main::ConfigurationData{'allow-similiar-search'} eq "yes") ) {
4109    
4110     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Number of similar documents retrieved (max): </TD> <TD ALIGN=LEFT VALIGN=TOP><SELECT NAME=\"SimilarDocuments\">\n");
4111     foreach $ItemEntry ( @main::SimilarDocuments ) {
4112     $Value = (defined($SimilarDocuments) && ($SimilarDocuments eq $ItemEntry)) ? "SELECTED" : "";
4113     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry\n");
4114     }
4115     print("</SELECT></TD></TR>\n");
4116     }
4117    
4118    
4119    
4120    
4121     # Are regular searches enabled?
4122     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4123    
4124     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4125    
4126     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> <B> Saved Searches Defaults: </B> </TD></TR>\n");
4127    
4128     # Send a pull-down which allows the user to select the automatic search frequency (default to weekly)
4129     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Saved search frequency: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
4130     foreach $ItemEntry ( @main::SearchFrequencies ) {
4131     $Value = (defined($SearchFrequency) && ($SearchFrequency eq $ItemEntry)) ? "SELECTED" : "";
4132     print("<OPTION VALUE=\"$ItemEntry\" $Value> $ItemEntry \n");
4133     }
4134     print("</SELECT> </TD></TR>\n");
4135    
4136     # Send a pull-down which allows the user to select the automatic search delivery format
4137     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Saved search delivery format: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryFormat\">\n");
4138     foreach $ItemEntry ( sort(keys(%main::DeliveryFormats)) ) {
4139     $Value = (defined($DeliveryFormat) && ($DeliveryFormat eq $ItemEntry)) ? "SELECTED" : "";
4140     print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::DeliveryFormats{$ItemEntry}\n");
4141     }
4142     print("</SELECT> </TD></TR>\n");
4143    
4144     # Send a pull-down which allows the user to select the automatic delivery method
4145     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Saved search delivery method: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
4146     foreach $ItemEntry ( sort(keys(%main::DeliveryMethods)) ) {
4147     $Value = (defined($DeliveryMethod) && ($DeliveryMethod eq $ItemEntry)) ? "SELECTED" : "";
4148     print("<OPTION VALUE=\"$ItemEntry\" $Value> $main::DeliveryMethods{$ItemEntry}\n");
4149     }
4150     print("</SELECT> </TD></TR>\n");
4151     }
4152    
4153    
4154     print("</FORM>\n");
4155     print("</TABLE>\n");
4156    
4157    
4158    
4159     # Bail from the settings
4160     bailFromGetUserSettings:
4161    
4162     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4163     undef(%Value);
4164     $Value{'GetUserSettings'} = "GetUserSettings";
4165     &vSendMenuBar(%Value);
4166     undef(%Value);
4167    
4168     &vSendHTMLFooter;
4169    
4170     return;
4171    
4172     }
4173    
4174    
4175    
4176    
4177    
4178    
4179     #--------------------------------------------------------------------------
4180     #
4181     # Function: vSetUserSettings()
4182     #
4183     # Purpose: This function saves the user setting
4184     #
4185     # Called by:
4186     #
4187     # Parameters: void
4188     #
4189     # Global Variables: %main::ConfigurationData, %main::FormData,
4190     # $main::UserSettingsFilePath, $main::RemoteUser,
4191     #
4192     # Returns: void
4193     #
4194     sub vSetUserSettings {
4195    
4196     my (%Value);
4197    
4198    
4199     # Return an error if the remote user name/account directory is not defined
4200     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4201     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4202     &vSendHTMLFooter;
4203     return;
4204     }
4205    
4206    
4207     # Make sure that we send the header
4208     &vSendHTMLHeader("My Settings", undef);
4209     undef(%Value);
4210     &vSendMenuBar(%Value);
4211    
4212    
4213     # Save the user settings
4214     undef(%Value);
4215     $Value{'UserName'} = $main::FormData{'UserName'};
4216     $Value{'EmailAddress'} = $main::FormData{'EmailAddress'};
4217     $Value{'DefaultSearch'} = $main::FormData{'DefaultSearch'};
4218 dpavlin 1.15 $Value{'SelectedDatabases'} = $main::FormData{'Database'};
4219 dpavlin 1.1 if ( defined($Value{'SelectedDatabases'}) ) {
4220     $Value{'SelectedDatabases'} =~ s/\0/,/g;
4221     }
4222     $Value{'SearchHistory'} = $main::FormData{'SearchHistory'};
4223     $Value{'SearchFrequency'} = $main::FormData{'SearchFrequency'};
4224     $Value{'DeliveryFormat'} = $main::FormData{'DeliveryFormat'};
4225     $Value{'DeliveryMethod'} = $main::FormData{'DeliveryMethod'};
4226     $Value{'SummaryType'} = $main::FormData{'SummaryType'};
4227     $Value{'SummaryLength'} = $main::FormData{'SummaryLength'};
4228     $Value{'SimilarDocuments'} = $main::FormData{'SimilarDocuments'};
4229    
4230    
4231     # Save the user settings file
4232     if ( &iSaveXMLFileFromHash($main::UserSettingsFilePath, "UserSettings", %Value) ) {
4233    
4234     print("<H3> Postavke: </H3>\n");
4235     print("<H3><CENTER> Postavke su uspje¹no snimljene! </CENTER></H3>\n");
4236     print("<P>\n");
4237     }
4238     else {
4239    
4240     # The settings could not be saved, so we inform the user of the fact
4241     &vHandleError("User Settings", "Sorry, we failed to saved your settings");
4242     }
4243    
4244    
4245    
4246     # Bail from the settings
4247     bailFromSetUserSettings:
4248    
4249     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4250     undef(%Value);
4251     &vSendMenuBar(%Value);
4252    
4253     &vSendHTMLFooter;
4254    
4255     return;
4256    
4257     }
4258    
4259    
4260    
4261    
4262    
4263    
4264     #--------------------------------------------------------------------------
4265     #
4266     # Function: vPurgeSearchHistory()
4267     #
4268     # Purpose: This function purges the search history files.
4269     #
4270     # Called by:
4271     #
4272     # Parameters: void
4273     #
4274     # Global Variables: $main::DefaultMaxSearchHistory, $main::UserSettingsFilePath,
4275     # $main::SearchHistoryFileNamePrefix, $main::UserAccountDirectoryPath
4276     #
4277     # Returns: void
4278     #
4279     sub vPurgeSearchHistory {
4280    
4281     my ($MaxSearchHistory, @SearchHistoryList, $SearchHistoryEntry);
4282    
4283    
4284     # Return if the remote user name/account directory is not defined
4285     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4286     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4287     &vSendHTMLFooter;
4288     return;
4289     }
4290    
4291    
4292     # Get the max number of entries in the search history
4293     $MaxSearchHistory = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "SearchHistory");
4294    
4295     # Set the detault max number of entries if it was not gotten from the user settings
4296     if ( !defined($MaxSearchHistory) ) {
4297     $MaxSearchHistory = $main::DefaultMaxSearchHistory;
4298     }
4299    
4300    
4301     # Read all the search history files
4302     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4303     @SearchHistoryList = map("$main::UserAccountDirectoryPath/$_" ,
4304     reverse(sort(grep(/$main::SearchHistoryFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
4305     closedir(USER_ACCOUNT_DIRECTORY);
4306    
4307    
4308     # Purge the excess search history files
4309     if ( scalar(@SearchHistoryList) > $MaxSearchHistory ) {
4310    
4311     # Splice out the old stuff, and loop over it deleting the files
4312     for $SearchHistoryEntry ( splice(@SearchHistoryList, $MaxSearchHistory) ) {
4313     unlink($SearchHistoryEntry);
4314     }
4315     }
4316    
4317     return;
4318    
4319     }
4320    
4321    
4322    
4323    
4324     #--------------------------------------------------------------------------
4325     #
4326     # Function: vListSearchHistory()
4327     #
4328     # Purpose: This function lists the search history for the user, the
4329     # entries are listed in reverse chronological order (most
4330     # recent first).
4331     #
4332     # In addition, the search history will be scanned and excess
4333     # searches will be purged.
4334     #
4335     # Called by:
4336     #
4337     # Parameters: void
4338     #
4339     # Global Variables: %main::ConfigurationData, $main::UserAccountDirectoryPath,
4340     # $main::XMLFileNameExtension, $main::SearchHistoryFileNamePrefix,
4341     # $main::RemoteUser
4342     #
4343     # Returns: void
4344     #
4345     sub vListSearchHistory {
4346    
4347     my (@SearchHistoryList, @QualifiedSearchHistoryList, $SearchHistoryEntry);
4348     my ($SearchString, $CreationTime, $SearchAndRfDocumentURL, $HeaderName, $Database);
4349     my ($Value, %Value, @Values);
4350    
4351    
4352     # Return an error if the remote user name/account directory is not defined
4353     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4354     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4355     &vSendHTMLFooter;
4356     return;
4357     }
4358    
4359    
4360    
4361     # Make sure that we send the header
4362     &vSendHTMLHeader("Prija¹nja pretra¾ivanja", undef);
4363     undef(%Value);
4364     $Value{'ListSearchHistory'} = "ListSearchHistory";
4365     &vSendMenuBar(%Value);
4366     undef(%Value);
4367    
4368    
4369     # Purge the search history files
4370     &vPurgeSearchHistory;
4371    
4372    
4373     # Read all the search history files
4374     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4375     @SearchHistoryList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::SearchHistoryFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
4376     closedir(USER_ACCOUNT_DIRECTORY);
4377    
4378    
4379     # Loop over each search history file checking that it is valid
4380     for $SearchHistoryEntry ( @SearchHistoryList ) {
4381    
4382     # Get the header name from the XML search history file
4383     $HeaderName = &sGetObjectTagFromXMLFile($SearchHistoryEntry);
4384    
4385     # Check that the entry is valid and add it to the qualified list
4386     if ( defined($HeaderName) && ($HeaderName eq "SearchHistory") ) {
4387     push @QualifiedSearchHistoryList, $SearchHistoryEntry;
4388     }
4389     else {
4390     # Else we delete this invalid search history file
4391     unlink($SearchHistoryEntry);
4392     }
4393     }
4394    
4395    
4396    
4397     # Display the search history
4398     print("<H3> Prija¹nja pretra¾ivanja: </H3>\n");
4399    
4400     # Print up the search history, if there is none, we put up a nice message
4401     if ( scalar(@QualifiedSearchHistoryList) > 0 ) {
4402    
4403     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
4404    
4405    
4406     for $SearchHistoryEntry ( @QualifiedSearchHistoryList ) {
4407    
4408     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
4409    
4410     # Get information from the XML search history file
4411     ($HeaderName, %Value) = &shGetHashFromXMLFile($SearchHistoryEntry);
4412    
4413     # Get the search file name and encode it
4414     $SearchHistoryEntry = ($SearchHistoryEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $SearchHistoryEntry;
4415     $SearchHistoryEntry = &lEncodeURLData($SearchHistoryEntry);
4416    
4417     $CreationTime = $Value{'CreationTime'};
4418     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
4419     %Value = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
4420     $SearchString = &sMakeSearchString(%Value);
4421     if ( defined($SearchString) ) {
4422     $SearchString =~ s/{.*?}//gs;
4423     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
4424     }
4425     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
4426    
4427    
4428     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD><TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
4429    
4430     # Get the local databases from the search and list their descriptions
4431     if ( defined($Value{'Database'}) ) {
4432    
4433     # Initialize the temp list
4434     undef(@Values);
4435    
4436     # Loop over each database
4437     foreach $Database ( split(/\0/, $Value{'Database'}) ) {
4438     $Value = &lEncodeURLData($Database);
4439     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> ");
4440     }
4441    
4442     # Print the list if there are any entries in it
4443     if ( scalar(@Values) > 0 ) {
4444     printf("<TR><TD ALIGN=LEFT VALIGN=TOP> Database%s: </TD><TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>\n",
4445     scalar(@Values) > 1 ? "s" : "", join(", ", @Values));
4446     }
4447     }
4448    
4449     if ( defined($Value{'RfDocument'}) ) {
4450     print("<TR>");
4451     &bDisplayDocuments("Feedback Document", $Value{'RfDocument'}, "RfDocument", undef, undef, 1);
4452     print("</TR>");
4453     }
4454    
4455     $Value = &sGetPrintableDateFromTime($CreationTime);
4456     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD><TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
4457    
4458     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");
4459    
4460     }
4461    
4462     print("</TABLE>\n");
4463     }
4464     else {
4465     print("<H3><CENTER> Sorry, currently there is no search history. </CENTER></H3>\n");
4466     }
4467    
4468    
4469    
4470     # Bail from the search history
4471     bailFromListSearchHistory:
4472    
4473     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4474     undef(%Value);
4475     $Value{'ListSearchHistory'} = "ListSearchHistory";
4476     &vSendMenuBar(%Value);
4477     undef(%Value);
4478    
4479     &vSendHTMLFooter;
4480    
4481     return;
4482    
4483     }
4484    
4485    
4486    
4487    
4488    
4489     #--------------------------------------------------------------------------
4490     #
4491     # Function: vGetSearchHistory()
4492     #
4493     # Purpose: This function displays a search history file to the user.
4494     #
4495     # Called by:
4496     #
4497     # Parameters: void
4498     #
4499     # Global Variables: %main::ConfigurationData, %main::FormData,
4500     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
4501     # $main::SearchHistoryFileNamePrefix, $main::RemoteUser
4502     #
4503     # Returns: void
4504     #
4505     sub vGetSearchHistory {
4506    
4507     my ($SearchAndRfDocumentURL, $SearchResults, $QueryReport, $CreationTime);
4508     my ($SearchHistoryEntry, $HeaderName, $Status);
4509     my ($Value, %Value);
4510    
4511    
4512    
4513     # Return an error if the remote user name/account directory is not defined
4514     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4515     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4516     &vSendHTMLFooter;
4517     return;
4518     }
4519    
4520    
4521     # Create the search history file name
4522     $SearchHistoryEntry = $main::UserAccountDirectoryPath . "/" . $main::FormData{'SearchHistoryObject'};
4523    
4524    
4525     # Check to see if the XML search history file requested is there
4526     if ( ! -f $SearchHistoryEntry ) {
4527     # Could not find the search history file
4528     &vHandleError("Display Search History", "Sorry, we cant to access this search history object because it is not there");
4529     goto bailFromGetSearchHistory;
4530     }
4531    
4532    
4533     # Get information from the XML search history file
4534     ($HeaderName, %Value) = &shGetHashFromXMLFile($SearchHistoryEntry);
4535    
4536     # Check that the entry is valid
4537     if ( !(defined($HeaderName) && ($HeaderName eq "SearchHistory")) ) {
4538     &vHandleError("Display Search History", "Sorry, this search history object is invalid");
4539     goto bailFromGetSearchHistory;
4540     }
4541    
4542    
4543    
4544     # At this point, the XML search history file is there and is valid,
4545     # so we can go ahead and display it
4546     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
4547     $SearchResults = $Value{'SearchResults'};
4548     $QueryReport = $Value{'QueryReport'};
4549     $CreationTime = $Value{'CreationTime'};
4550    
4551     %main::FormData = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
4552    
4553     # Make sure that we send the header
4554     &vSendHTMLHeader("Display Search History", undef);
4555     undef(%Value);
4556     &vSendMenuBar(%Value);
4557    
4558    
4559     ($Status, $QueryReport) = &bsDisplaySearchResults("Rezultati prija¹njih pretra¾ivanja:", undef, undef, undef, $SearchResults, $QueryReport, $ENV{'SCRIPT_NAME'}, 1, 1, 1, %main::FormData);
4560    
4561    
4562     # Bail from displaying the search history
4563     bailFromGetSearchHistory:
4564    
4565     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4566     undef(%Value);
4567     &vSendMenuBar(%Value);
4568    
4569     &vSendHTMLFooter;
4570    
4571     return;
4572    
4573     }
4574    
4575    
4576    
4577    
4578    
4579    
4580     #--------------------------------------------------------------------------
4581     #
4582     # Function: vGetSaveSearch()
4583     #
4584     # Purpose: This function displays a form to the user allowing them to save a search
4585     #
4586     # Called by:
4587     #
4588     # Parameters: void
4589     #
4590     # Global Variables: %main::ConfigurationData, %main::FormData,
4591     # $main::UserSettingsFilePath, $main::RemoteUser,
4592     #
4593     # Returns: void
4594     #
4595     sub vGetSaveSearch {
4596    
4597    
4598     my ($SearchString, $Database);
4599     my ($HeaderName, $SearchFrequency, $DeliveryFormat, $DeliveryMethod);
4600     my ($JavaScript, $EmailAddress);
4601     my ($Value, @Values, %Value, $ValueEntry);
4602    
4603    
4604     # Return an error if the remote user name/account directory is not defined
4605     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4606     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4607     &vSendHTMLFooter;
4608     return;
4609     }
4610    
4611    
4612     $JavaScript = '<SCRIPT LANGUAGE="JavaScript">
4613     <!-- hide
4614     function checkForm( Form ) {
4615     if ( !checkField( Form.SearchName, "Search name" ) )
4616     return false
4617     return true
4618     }
4619     function checkField( Field, Name ) {
4620     if ( Field.value == "" ) {
4621     errMsg( Field, "Niste ispunili polje \'"+Name+"\' ." )
4622     return false
4623     }
4624     else {
4625     return true
4626     }
4627     }
4628     function errMsg( Field, Msg ) {
4629     alert( Msg )
4630     Field.focus()
4631     return
4632     }
4633     // -->
4634     </SCRIPT>
4635     ';
4636    
4637    
4638    
4639     # Make sure that we send the header
4640     &vSendHTMLHeader("Save this Search", $JavaScript);
4641     undef(%Value);
4642     &vSendMenuBar(%Value);
4643    
4644    
4645     # Give the user a form to fill out
4646 dpavlin 1.20 print("<H3> Èuvanje upita: </H3>\n");
4647 dpavlin 1.1
4648    
4649    
4650     # Get information from the XML saved search file
4651     ($HeaderName, %Value) = &shGetHashFromXMLFile($main::UserSettingsFilePath);
4652    
4653     $SearchFrequency = $Value{'SearchFrequency'};
4654     $DeliveryFormat = $Value{'DeliveryFormat'};
4655     $DeliveryMethod = $Value{'DeliveryMethod'};
4656     $EmailAddress = $Value{'EmailAddress'};
4657    
4658    
4659     # Print up the table start
4660     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
4661    
4662     # Start the form
4663     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetSaveSearch\" onSubmit=\"return checkForm(this)\" METHOD=POST>\n");
4664    
4665     # Send the buttons
4666     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");
4667    
4668     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4669    
4670     # Print up the search string
4671     $SearchString = &sMakeSearchString(%main::FormData);
4672     if ( defined($SearchString) ) {
4673     $SearchString =~ s/{.*?}//gs;
4674     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
4675     }
4676     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
4677     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
4678    
4679     # Get the local databases from the search and list their descriptions
4680     if ( defined($main::FormData{'Database'}) ) {
4681    
4682     # Initialize the temp list
4683     undef(@Values);
4684    
4685     foreach $Database ( sort(split(/\0/, $main::FormData{'Database'})) ) {
4686     $Value = &lEncodeURLData($Database);
4687     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> ");
4688     }
4689    
4690     # Print the list if there are any entries in it
4691     if ( scalar(@Values) > 0 ) {
4692     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));
4693     }
4694     }
4695    
4696     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4697    
4698     # Send the search name and search description fields
4699 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Naziv (obavezno): </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT NAME=\"SearchName\" TYPE=TEXT SIZE=45> </TD></TR>\n");
4700 dpavlin 1.1
4701 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> <TEXTAREA INPUT NAME=\"SearchDescription\" COLS=45 ROWS=6 WRAP=VIRTUAL></TEXTAREA> </TD></TR>\n");
4702 dpavlin 1.1
4703     if ( defined($main::FormData{'RfDocument'}) ) {
4704     print("<TR>\n");
4705     &bDisplayDocuments("Feedback Document", $main::FormData{'RfDocument'}, "RfDocument", undef, undef, 1);
4706     print("</TR>\n");
4707     }
4708    
4709    
4710     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4711    
4712 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Kliknite na ovaj kvadratiæ ako ¾elite postojeæi upit s istim imenom zamijeniti ovim novim: </TD> <TD ALIGN=LEFT VALIGN=TOP><INPUT TYPE=\"checkbox\" NAME=\"OverWrite\" VALUE=\"yes\"> </TD></TR>\n");
4713 dpavlin 1.1
4714    
4715    
4716     # Are regular searches enabled?
4717     if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
4718    
4719     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
4720    
4721 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Kliknite ovaj kvadratiæ ukoliko ¾elite automatsko periodièko pretra¾ivanje po ovom upitu: </TD> <TD ALIGN=LEFT VALIGN=TOP> <INPUT TYPE=CHECKBOX VALUE=\"yes\" NAME=\"Regular\"> </TD></TR>\n");
4722 dpavlin 1.1
4723     # Send a pull-down which allows the user to select the automatic search frequency
4724 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite frekvenciju automatskog pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
4725 dpavlin 1.1 foreach $ValueEntry ( @main::SearchFrequencies ) {
4726     $Value = (defined($SearchFrequency) && ($SearchFrequency eq $ValueEntry)) ? "SELECTED" : "";
4727     print("<OPTION VALUE=\"$ValueEntry\" $Value> $ValueEntry \n");
4728     }
4729     print("</SELECT> </TD></TR>\n");
4730    
4731     # Send a pull-down which allows the user to select the automatic search delivery format
4732 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite format za isporuku rezultata pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryFormat\">\n");
4733 dpavlin 1.1 foreach $ValueEntry ( sort(keys(%main::DeliveryFormats)) ) {
4734     $Value = (defined($DeliveryFormat) && ($DeliveryFormat eq $ValueEntry)) ? "SELECTED" : "";
4735     print("<OPTION VALUE=\"$ValueEntry\" $Value> $main::DeliveryFormats{$ValueEntry}\n");
4736     }
4737     print("</SELECT> </TD></TR>\n");
4738    
4739     # Send a pull-down which allows the user to select the automatic search delivery method
4740 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite metodu isporuke: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
4741 dpavlin 1.1 foreach $ValueEntry ( sort(keys(%main::DeliveryMethods)) ) {
4742     $Value = (defined($DeliveryMethod) && ($DeliveryMethod eq $ValueEntry)) ? "SELECTED" : "";
4743     print("<OPTION VALUE=\"$ValueEntry\" $Value> $main::DeliveryMethods{$ValueEntry}\n");
4744     }
4745     print("</SELECT> </TD></TR>\n");
4746     }
4747    
4748    
4749     # List the hidden fields
4750     %Value = &hParseURLIntoHashTable(&sMakeSearchAndRfDocumentURL(%main::FormData));
4751     foreach $Value ( keys(%Value) ) {
4752     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
4753     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
4754     }
4755     }
4756    
4757     print("</FORM>\n");
4758     print("</TABLE>\n");
4759    
4760     if ( !defined($EmailAddress) &&
4761     (defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes")) ) {
4762     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4763     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");
4764     }
4765    
4766    
4767     # Bail from saving the search
4768     bailFromGetSaveSearch:
4769    
4770     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4771     undef(%Value);
4772     &vSendMenuBar(%Value);
4773    
4774     &vSendHTMLFooter;
4775    
4776     return;
4777    
4778     }
4779    
4780    
4781    
4782    
4783    
4784    
4785     #--------------------------------------------------------------------------
4786     #
4787     # Function: vSetSaveSearch()
4788     #
4789     # Purpose: This function saves that search and search name in a search file
4790     #
4791     # Called by:
4792     #
4793     # Parameters: void
4794     #
4795     # Global Variables: %main::ConfigurationData, %main::FormData,
4796     # $main::UserSettingsFilePath, $main::RemoteUser,
4797     #
4798     # Returns: void
4799     #
4800     sub vSetSaveSearch {
4801    
4802    
4803     my ($SearchAndRfDocumentURL, $SearchString);
4804     my (@SavedSearchList, $SavedSearchEntry, $SavedSearchFilePath);
4805     my ($EmailAddress, $SearchName, $CreationTime, $LastRunTime);
4806     my ($Value, %Value);
4807    
4808    
4809     # Return an error if the remote user name/account directory is not defined
4810     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4811     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4812     &vSendHTMLFooter;
4813     return;
4814     }
4815    
4816    
4817     # Make sure that we send the header
4818     &vSendHTMLHeader("Saèuvana pretra¾ivanja", undef);
4819     undef(%Value);
4820     &vSendMenuBar(%Value);
4821    
4822    
4823     # Check that the required fields are filled in
4824     if ( !defined($main::FormData{'SearchName'}) ) {
4825    
4826     # A required field is missing, so we suggest corrective action to the user.
4827     print("<H3> Snimanje pretra¾ivanja: </H3>\n");
4828     print("<H3><CENTER> Oprostite, nedostaju neke informacije. </CENTER></H3>\n");
4829     print("<P>\n");
4830     print("Polje <B>'search name'</B> mora biti ispunjeno da bi se moglo saèuvati pretra¾ivanje.<P>\n");
4831     print("Kliknite na <B>'Back'</B> u svom browseru, popunite polje koje nedostaje i poku¹ajte ponovo.\n");
4832     print("<P>\n");
4833    
4834     goto bailFromSetSaveSearch;
4835    
4836     }
4837    
4838    
4839     # Read all the saved search files
4840     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4841     @SavedSearchList = map("$main::UserAccountDirectoryPath/$_", grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)));
4842     closedir(USER_ACCOUNT_DIRECTORY);
4843    
4844    
4845     # Loop over each saved search file checking that it is valid
4846     for $SavedSearchEntry ( @SavedSearchList ) {
4847    
4848     $SearchName = &sGetTagValueFromXMLFile($SavedSearchEntry, "SearchName");
4849    
4850     if ( $SearchName eq $main::FormData{'SearchName'} ) {
4851     $SavedSearchFilePath = $SavedSearchEntry;
4852     last;
4853     }
4854     }
4855    
4856     # Check that the saved search file does not already exist
4857     if ( defined($SavedSearchFilePath) && ($SavedSearchFilePath ne "")
4858     && !(defined($main::FormData{'OverWrite'}) && ($main::FormData{'OverWrite'} eq "yes")) ) {
4859    
4860     # There is already a saved search with this name, so we suggest corrective action to the user.
4861 dpavlin 1.20 print("<H3> Èuvanje upita: </H3>\n");
4862     print("<H3><CENTER> Veæ postoji upit pod ovim imenom. </CENTER></H3>\n");
4863 dpavlin 1.1 print("<P>\n");
4864 dpavlin 1.20 print("Kliknite <B>'back'</B> u browseru, promijenite <B>'Naziv'</B> i poku¹ajte ponovo, \n");
4865     print("ili kliknuti na kvadratiæ koji vam omoguæava da automatski presnimite saèuvani upit s istim imenom.\n");
4866 dpavlin 1.1 print("<P>\n");
4867    
4868     goto bailFromSetSaveSearch;
4869     }
4870    
4871    
4872     # Get the email address of this user
4873     $Value = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
4874    
4875     # Check this user has an email address defined if they want to run the search on a regular basis
4876     if ( !defined($Value) && (defined($main::FormData{'Regular'}) && ($main::FormData{'Regular'} eq "yes")) ) {
4877    
4878     # Regular delivery was requested, but the email address was not specified in the settings
4879 dpavlin 1.20 print("<H3> Èuvanje upita: </H3>\n");
4880     print("<H3><CENTER> E-mail adresa nije specificirana u va¹im postavkama. </CENTER></H3>\n");
4881 dpavlin 1.1 print("<P>\n");
4882 dpavlin 1.20 print("Potrebno je specificirati e-mail adresu ukoliko ¾elite da se pretra¾ivanje po ovom upitu odvije periodièno. \n");
4883     print("bez e-mail adrese, nismo vam u moguænosti isporuèiti rezultate. <P>\n");
4884     print("Kliknite na <B>'Korisnièke postavke'</B>, upi¹ite e-mail adresu i saèuvajte postavke, \n");
4885     print("nakon toga kliknite na <B>'back'</B> u svom browseru tri puta kako biste se vratili na formu koja vam nudi da saèuvate upit.\n");
4886 dpavlin 1.1 print("<P>\n");
4887    
4888     goto bailFromSetSaveSearch;
4889     }
4890    
4891    
4892     # All the checks have been passed, so we can go ahead and save the search
4893    
4894     $CreationTime = time();
4895     $LastRunTime = $CreationTime;
4896    
4897     # Erase the search frequency and the delivery method if this is not a regular search
4898     if ( !(defined($main::FormData{'Regular'}) && ($main::FormData{'Regular'} eq "yes")) ) {
4899     $main::FormData{'SearchFrequency'} = "";
4900     $main::FormData{'DeliveryFormat'} = "";
4901     $main::FormData{'DeliveryMethod'} = "";
4902     $LastRunTime = "";
4903     }
4904    
4905    
4906     # Get the URL search string
4907     $SearchAndRfDocumentURL = &sMakeSearchAndRfDocumentURL(%main::FormData);
4908    
4909     # Save the search
4910     if ( &iSaveSearch(undef, $main::FormData{'SearchName'}, $main::FormData{'SearchDescription'}, $SearchAndRfDocumentURL, $main::FormData{'SearchFrequency'}, $main::FormData{'DeliveryFormat'}, $main::FormData{'DeliveryMethod'}, "Active", $CreationTime, $LastRunTime) ) {
4911    
4912     print("<H3> Saving a Search: </H3>\n");
4913     print("<P>\n");
4914     print("<H3><CENTER> Your search was successfully saved. </CENTER></H3>\n");
4915    
4916     # Delete the overwritten search file
4917     if ( defined($SavedSearchFilePath) && ($SavedSearchFilePath ne "") ) {
4918     unlink($SavedSearchFilePath);
4919     }
4920     }
4921     else {
4922    
4923     # The search could not be saved, so we inform the user of the fact
4924     &vHandleError("Saving a Search", "Sorry, we failed to save this search");
4925     goto bailFromSetSaveSearch;
4926     }
4927    
4928    
4929     # Bail from saving the search
4930     bailFromSetSaveSearch:
4931    
4932     print("<CENTER><HR WIDTH=50%></CENTER>\n");
4933     undef(%Value);
4934     &vSendMenuBar(%Value);
4935    
4936     &vSendHTMLFooter;
4937    
4938     return;
4939    
4940     }
4941    
4942    
4943    
4944    
4945    
4946    
4947     #--------------------------------------------------------------------------
4948     #
4949     # Function: vListSavedSearch()
4950     #
4951     # Purpose: This function allows the user list the saved searches and
4952     # sets up the links allowing the user to get a search form
4953     # filled with the search
4954     #
4955     # Called by:
4956     #
4957     # Parameters: void
4958     #
4959     # Global Variables: %main::ConfigurationData, %main::FormData,
4960     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
4961     # $main::SavedSearchFileNamePrefix, $main::RemoteUser
4962     #
4963     # Returns: void
4964     #
4965     sub vListSavedSearch {
4966    
4967     my (@SavedSearchList, @QualifiedSavedSearchList, $SavedSearchEntry, $HeaderName, $SearchString, $Database);
4968     my ($SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $LastRunTime);
4969     my (@Values, $Value, %Value);
4970    
4971    
4972     # Return an error if the remote user name/account directory is not defined
4973     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
4974     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
4975     &vSendHTMLFooter;
4976     return;
4977     }
4978    
4979    
4980     # Make sure that we send the header
4981     &vSendHTMLHeader("Saèuvana pretra¾ivanja", undef);
4982     undef(%Value);
4983     $Value{'ListSavedSearch'} = "ListSavedSearch";
4984     &vSendMenuBar(%Value);
4985     undef(%Value);
4986    
4987    
4988     # Read all the saved search files
4989     opendir(USER_ACCOUNT_DIRECTORY, $main::UserAccountDirectoryPath);
4990     @SavedSearchList = map("$main::UserAccountDirectoryPath/$_", reverse(sort(grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY)))));
4991     closedir(USER_ACCOUNT_DIRECTORY);
4992    
4993    
4994     # Loop over each search history file checking that it is valid
4995     for $SavedSearchEntry ( @SavedSearchList ) {
4996    
4997     # Get the header name from the XML saved search file
4998     $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchEntry);
4999    
5000     # Check that the entry is valid and add it to the qualified list
5001     if ( defined($HeaderName) && ($HeaderName eq "SavedSearch") ) {
5002     push @QualifiedSavedSearchList, $SavedSearchEntry;
5003     }
5004     else {
5005     # Else we delete this invalid saved search file
5006     unlink($SavedSearchEntry);
5007     }
5008     }
5009    
5010    
5011     # Print out the saved searches
5012 dpavlin 1.20 print("<H3> Saèuvani upiti: </H3>\n");
5013 dpavlin 1.1
5014    
5015    
5016     # Print up the saved searches, if there is none, we put up a nice message
5017     if ( scalar(@QualifiedSavedSearchList) > 0 ) {
5018    
5019     # Start the table
5020     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
5021    
5022     # Start the form
5023     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
5024    
5025    
5026     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3> \n");
5027     print("<SELECT NAME=\"Action\">\n");
5028 dpavlin 1.20 print("<OPTION VALUE=\"ActivateSavedSearch\">Ukljuèi periodièno automatsko pretra¾ivanje po odabranim upitima\n");
5029     print("<OPTION VALUE=\"SuspendSavedSearch\">Iskljuèi periodièno automatsko pretra¾ivanje po odabranim upitima\n");
5030     print("<OPTION VALUE=\"DeleteSavedSearch\">Obri¹i oznaèene saèuvane upite\n");
5031 dpavlin 1.1 print("</SELECT>\n");
5032     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
5033     print("</TD></TR>\n");
5034    
5035     for $SavedSearchEntry ( @QualifiedSavedSearchList ) {
5036    
5037     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
5038    
5039     # Get information from the XML saved search file
5040     ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchEntry);
5041    
5042     # Get the saved search file name and encode it
5043     $SavedSearchEntry = ($SavedSearchEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $SavedSearchEntry;
5044     $SavedSearchEntry = &lEncodeURLData($SavedSearchEntry);
5045    
5046    
5047     $SearchName = $Value{'SearchName'};
5048     $SearchDescription = $Value{'SearchDescription'};
5049     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
5050     $SearchFrequency = $Value{'SearchFrequency'};
5051     $SearchStatus = $Value{'SearchStatus'};
5052     $DeliveryFormat = $Value{'DeliveryFormat'};
5053     $DeliveryMethod = $Value{'DeliveryMethod'};
5054     $CreationTime = $Value{'CreationTime'};
5055     $LastRunTime = $Value{'LastRunTime'};
5056    
5057     # Parse the URL Search string into a hash so that we can get at it's components
5058     %Value = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
5059    
5060     $SearchString = &sMakeSearchString(%Value);
5061     if ( defined($SearchString) ) {
5062     $SearchString =~ s/{.*?}//gs;
5063     $SearchString = ($SearchString =~ /\S/) ? $SearchString : undef;
5064     }
5065     $SearchString = defined($SearchString) ? $SearchString : "(No search terms defined)";
5066    
5067     # Print the link
5068     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");
5069    
5070     # Print the search description
5071     $SearchDescription = defined($SearchDescription) ? $SearchDescription : "(Nije naveden)";
5072     $SearchDescription =~ s/\n/<BR>/g;
5073     $SearchDescription =~ s/\r/<BR>/g;
5074     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchDescription </TD></TR>\n");
5075    
5076     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Upit: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchString </TD></TR>\n");
5077    
5078     # Get the local databases from the search and list their descriptions
5079     if ( defined($Value{'Database'}) ) {
5080    
5081     # Initialize the temp list
5082     undef(@Values);
5083    
5084     # Loop over each database
5085     foreach $Database ( split(/\0/, $Value{'Database'}) ) {
5086     $Value = &lEncodeURLData($Database);
5087     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> ");
5088     }
5089    
5090     # Print the list if there are any entries in it
5091     if ( scalar(@Values) > 0 ) {
5092     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));
5093     }
5094     }
5095    
5096    
5097     if ( defined($Value{'RfDocument'}) ) {
5098     print("<TR><TD></TD>\n");
5099     &bDisplayDocuments("Feedback Document", $Value{'RfDocument'}, "RfDocument", undef, undef, 1);
5100     print("</TR>\n");
5101     }
5102    
5103     undef(%Value);
5104    
5105    
5106     if ( defined($SearchFrequency) || defined($DeliveryFormat) || defined($DeliveryMethod) ) {
5107     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Run: </TD> <TD ALIGN=LEFT VALIGN=TOP> $SearchFrequency </TD></TR>\n");
5108     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Delivery format: </TD> <TD ALIGN=LEFT VALIGN=TOP> $main::DeliveryFormats{$DeliveryFormat} </TD></TR>\n");
5109     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Delivery method : </TD> <TD ALIGN=LEFT VALIGN=TOP> $main::DeliveryMethods{$DeliveryMethod} </TD></TR>\n");
5110     }
5111    
5112     $Value = &sGetPrintableDateFromTime($CreationTime);
5113     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5114    
5115    
5116     if ( defined($SearchFrequency) || defined($DeliveryFormat) || defined($DeliveryMethod) ) {
5117    
5118     if ( defined($LastRunTime) ) {
5119     $Value = &sGetPrintableDateFromTime($LastRunTime);
5120     print("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Last Run: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5121     }
5122    
5123     printf("<TR><TD></TD><TD ALIGN=LEFT VALIGN=TOP> Status: </TD> <TD ALIGN=LEFT VALIGN=TOP> %s </TD></TR>",
5124     (defined($SearchStatus) && ($SearchStatus eq "Active")) ? "Active" : "Suspended");
5125    
5126     }
5127    
5128 dpavlin 1.20 print("<TR><TD ALIGN=LEFT VALIGN=TOP></TD><TD ALIGN=LEFT VALIGN=TOP></TD> <TD ALIGN=LEFT VALIGN=TOP> <A HREF=\"$ENV{'SCRIPT_NAME'}/GetSavedSearch?SavedSearchObject=$SavedSearchEntry\" OnMouseOver=\"self.status='Display the search form with this search'; return true\"> [ Otvori formu za pretra¾ivanje s upisanim ovim upitom ] </A> </TD></TR>\n");
5129 dpavlin 1.1 }
5130    
5131     print("</FORM></TABLE>\n");
5132     }
5133     else {
5134     print("<H3><CENTER> Sorry, currently, there are no saved searches. </CENTER></H3>\n");
5135     }
5136    
5137    
5138    
5139    
5140     # Bail from displaying saved searches
5141     bailFromDisplaySavedSearch:
5142    
5143     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5144     undef(%Value);
5145     $Value{'ListSavedSearch'} = "ListSavedSearch";
5146     &vSendMenuBar(%Value);
5147     undef(%Value);
5148    
5149     &vSendHTMLFooter;
5150    
5151    
5152     return;
5153    
5154     }
5155    
5156    
5157    
5158    
5159    
5160    
5161     #--------------------------------------------------------------------------
5162     #
5163     # Function: vGetSavedSearch()
5164     #
5165     # Purpose: This function gets a saved search.
5166     #
5167     # Called by:
5168     #
5169     # Parameters: void
5170     #
5171     # Global Variables: %main::ConfigurationData, %main::FormData,
5172     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
5173     # $main::SavedSearchFileNamePrefix, $main::RemoteUser
5174     #
5175     # Returns: void
5176     #
5177     sub vGetSavedSearch {
5178    
5179     my ($HeaderName, $SavedSearchFilePath, $SearchAndRfDocumentURL, $DefaultSearch);
5180     my ($Value, %Value);
5181    
5182    
5183     # Return an error if the remote user name/account directory is not defined
5184     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5185     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5186     &vSendHTMLFooter;
5187     return;
5188     }
5189    
5190    
5191     # Set the saved search file path
5192     $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'SavedSearchObject'};
5193    
5194    
5195     # Check to see if the XML saved search file requested is there
5196     if ( ! -f $SavedSearchFilePath ) {
5197     # Could not find the saved search file
5198     &vHandleError("Prikaz saèuvaniog pretra¾ivanja", "Sorry, we cant to access this saved search object because it is not there");
5199     &vSendHTMLFooter;
5200     return;
5201     }
5202    
5203    
5204    
5205     # Get the data from the XML saved search file
5206     $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchFilePath);
5207    
5208     # Check that the entry is valid
5209     if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
5210     &vHandleError("Prikaz saèuvaniog pretra¾ivanja", "Sorry, this saved search object is invalid");
5211     &vSendHTMLFooter;
5212     return;
5213     }
5214    
5215    
5216     # All is fine, so we hand over the hash and get the search
5217     %main::FormData = &hParseURLIntoHashTable(&sGetTagValueFromXMLFile($SavedSearchFilePath, 'SearchAndRfDocumentURL'));
5218    
5219     $ENV{'PATH_INFO'} = "/GetSearch";
5220    
5221     # Display the search form, it will autoset itself from %main::FormData
5222     &vGetSearch;
5223    
5224     return;
5225    
5226     }
5227    
5228    
5229    
5230    
5231    
5232    
5233     #--------------------------------------------------------------------------
5234     #
5235     # Function: vProcessSavedSearch()
5236     #
5237     # Purpose: This function processes a saved search.
5238     #
5239     # Called by:
5240     #
5241     # Parameters: void
5242     #
5243     # Global Variables: %main::ConfigurationData, %main::FormData,
5244     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
5245     # $main::SavedSearchFileNamePrefix, $main::RemoteUser
5246     #
5247     # Returns: void
5248     #
5249     sub vProcessSavedSearch {
5250    
5251     my ($Title, $HeaderName, $SavedSearchFilePath, $SavedSearchObject);
5252     my ($Value, %Value);
5253    
5254    
5255     # Return an error if the remote user name/account directory is not defined
5256     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5257     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5258     &vSendHTMLFooter;
5259     return;
5260     }
5261    
5262    
5263     # Set the title
5264     if ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
5265 dpavlin 1.19 $Title = "Brisanje saèuvanih pretra¾ivanja";
5266 dpavlin 1.1 }
5267     elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
5268 dpavlin 1.19 $Title = "Ukljuèivanje automatskog periodiènog pretra¾ivanja";
5269 dpavlin 1.1 }
5270     elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
5271 dpavlin 1.19 $Title = "Iskljuèivanje automatskog periodiènog pretra¾ivanja";
5272 dpavlin 1.1 }
5273    
5274    
5275     # Make sure that we send the header
5276     &vSendHTMLHeader($Title, undef);
5277     undef(%Value);
5278     &vSendMenuBar(%Value);
5279    
5280    
5281     print("<H3> $Title: </H3>\n");
5282    
5283     # Check to see if the saved search object is defined
5284     if ( ! defined($main::FormData{'SavedSearchObject'}) ) {
5285     # Could not find the saved search object
5286 dpavlin 1.20 print("<H3><CENTER>Niste odabrali niti jedan upit. </CENTER></H3>\n");
5287 dpavlin 1.1 print("<P>\n");
5288 dpavlin 1.20 print("Potrebno je odabrati barem jedan saèuvani upit nad kojim æe se izvr¹iti akcija.\n");
5289 dpavlin 1.1 print("<P>\n");
5290     goto bailFromProcessSavedSearch;
5291     }
5292    
5293    
5294    
5295     # Loop over each saved search
5296     foreach $SavedSearchObject ( split(/\0/, $main::FormData{'SavedSearchObject'}) ) {
5297    
5298     # Set the saved search file path
5299     $SavedSearchFilePath = $main::UserAccountDirectoryPath . "/" . $SavedSearchObject;
5300    
5301     # Check to see if the XML saved search file requested is there
5302     if ( ! -f $SavedSearchFilePath ) {
5303     next;
5304     }
5305    
5306     # Get information from the XML saved search file
5307     ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchFilePath);
5308    
5309     # Check that the entry is valid
5310     if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
5311     next;
5312     }
5313    
5314    
5315     if ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
5316     if ( unlink($SavedSearchFilePath) ) {
5317 dpavlin 1.19 printf("<P>Uspje¹no pobrisano: %s\n", $Value{'SearchName'});
5318 dpavlin 1.1 }
5319     else {
5320 dpavlin 1.19 printf("<P>Nije pobrisano: %s\n", $Value{'SearchName'});
5321 dpavlin 1.1 }
5322     }
5323     elsif ( ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") || ($ENV{'PATH_INFO'} eq "/SuspendSavedSearch") ) {
5324    
5325     if ( !defined($Value{'SearchStatus'}) ) {
5326     printf("<P>Could not %s: %s, as it is not a regular search\n",
5327     ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "activate" : "suspend", $Value{'SearchName'});
5328     }
5329     else {
5330    
5331     $Value{'SearchStatus'} = ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "Active" : "Inactive" ;
5332    
5333     if ( &iSaveXMLFileFromHash($SavedSearchFilePath, "SavedSearch", %Value) ) {
5334 dpavlin 1.19 printf("<P>Uspje¹no %s: %s\n",
5335     ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "ukljuèeno" : "iskljuèeno", $Value{'SearchName'});
5336 dpavlin 1.1 }
5337     else {
5338 dpavlin 1.19 printf("<P>Nije %s: %s\n",
5339     ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "ukljuèeno" : "iskljuèeno", $Value{'SearchName'});
5340 dpavlin 1.1 }
5341     }
5342     }
5343     }
5344    
5345     print("<P>\n");
5346    
5347     # Bail from processing the saved search
5348     bailFromProcessSavedSearch:
5349    
5350     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5351     undef(%Value);
5352     &vSendMenuBar(%Value);
5353    
5354     &vSendHTMLFooter;
5355    
5356     return;
5357    
5358     }
5359    
5360    
5361    
5362    
5363    
5364    
5365     #--------------------------------------------------------------------------
5366     #
5367     # Function: vGetSaveFolder()
5368     #
5369     # Purpose: This function displays a form to the user allowing them to
5370     # save documents to a folder
5371     #
5372     # Called by:
5373     #
5374     # Parameters: void
5375     #
5376     # Global Variables: %main::ConfigurationData, %main::FormData,
5377     # $main::UserSettingsFilePath, $main::RemoteUser,
5378     #
5379     # Returns: void
5380     #
5381     sub vGetSaveFolder {
5382    
5383    
5384     my ($JavaScript);
5385     my ($Value, @Values, %Value, $ValueEntry);
5386    
5387    
5388    
5389     # Return an error if the remote user name/account directory is not defined
5390     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5391     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5392     &vSendHTMLFooter;
5393     return;
5394     }
5395    
5396    
5397     $JavaScript = '<SCRIPT LANGUAGE="JavaScript">
5398     <!-- hide
5399     function checkForm( Form ) {
5400     if ( !checkField( Form.FolderName, "Folder name" ) )
5401     return false
5402     return true
5403     }
5404     function checkField( Field, Name ) {
5405     if ( Field.value == "" ) {
5406     errMsg( Field, "Niste ispunili polje \'"+Name+"\'." )
5407     return false
5408     }
5409     else {
5410     return true
5411     }
5412     }
5413     function errMsg( Field, Msg ) {
5414     alert( Msg )
5415     Field.focus()
5416     return
5417     }
5418     // -->
5419     </SCRIPT>
5420     ';
5421    
5422    
5423     # Make sure that we send the header
5424     &vSendHTMLHeader("Saving a Document Folder", $JavaScript);
5425     undef(%Value);
5426     &vSendMenuBar(%Value);
5427    
5428    
5429     # Check that at least one document was selected
5430     if ( !defined($main::FormData{'Document'}) && !defined($main::FormData{'Documents'}) ) {
5431     print("<H3>Saving a Document Folder:</H3>\n");
5432     print("<H3><CENTER>Sorry, no document(s) were selected for saving.</CENTER></H3>\n");
5433     print("<P>\n");
5434     print("There needs to be a least one document selected in order to save it.\n");
5435     print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
5436     goto bailFromGetSaveFolder;
5437     }
5438    
5439    
5440     # Print up the title
5441 dpavlin 1.20 print("<H3> Kreiranje korisnièkog foldera: </H3>\n");
5442 dpavlin 1.1
5443     # Print up the form
5444     printf("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetSaveFolder\" onSubmit=\"return checkForm(this)\" METHOD=POST>\n");
5445    
5446     # Print up the table start
5447     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
5448    
5449     # Send the buttons
5450     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");
5451    
5452     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
5453    
5454     # Send the fields
5455     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");
5456    
5457     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");
5458    
5459     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
5460    
5461     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");
5462    
5463     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
5464    
5465     # List the documents
5466     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
5467    
5468     # Undefine the hash table in preparation
5469     undef(%Value);
5470    
5471     # Add document that were specifically selected
5472     if ( defined($main::FormData{'Document'}) ) {
5473     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5474     $Value{$Value} = $Value;
5475     }
5476     }
5477     # Otherwise add documents that were selected by default
5478     elsif ( defined($main::FormData{'Documents'}) ) {
5479     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
5480     $Value{$Value} = $Value;
5481     }
5482     }
5483    
5484     # Assemble the new content
5485     $main::FormData{'Document'} = join("\0", keys(%Value));
5486    
5487     # Delete the old content
5488     delete($main::FormData{'Documents'});
5489    
5490 dpavlin 1.20 ###FIX
5491 dpavlin 1.1 if ( defined($main::FormData{'Document'}) ) {
5492     print("<TR>\n");
5493     &bDisplayDocuments("Document", $main::FormData{'Document'}, "Document", undef, undef, 1);
5494     print("</TR>\n");
5495     }
5496     }
5497    
5498    
5499    
5500     # List the hidden fields
5501     %Value = &hParseURLIntoHashTable(&sMakeDocumentURL(%main::FormData));
5502     foreach $Value ( keys(%Value) ) {
5503     foreach $ValueEntry ( split(/\0/, $Value{$Value}) ) {
5504     print("<INPUT TYPE=HIDDEN NAME=\"$Value\" VALUE=\"$ValueEntry\">\n");
5505     }
5506     }
5507    
5508    
5509     # Retain the 'from' folder name if it is defined as these documents are coming from it
5510     if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
5511     print("<INPUT TYPE=HIDDEN NAME=\"FromDocumentFolderObject\" VALUE=\"$main::FormData{'FromDocumentFolderObject'}\">\n");
5512     }
5513    
5514    
5515     # Retain the 'merge' folder name if it is defined as these documents are coming from them
5516     if ( defined($main::FormData{'MergeDocumentFolderObject'}) ) {
5517     foreach $Value ( split(/\0/, $main::FormData{'MergeDocumentFolderObject'}) ) {
5518     print("<INPUT TYPE=HIDDEN NAME=\"MergeDocumentFolderObject\" VALUE=\"$Value\">\n");
5519     }
5520     }
5521    
5522     print("</TABLE>\n");
5523     print("</FORM>\n");
5524    
5525    
5526     # Bail from saving the document folder
5527     bailFromGetSaveFolder:
5528    
5529     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5530     undef(%Value);
5531     &vSendMenuBar(%Value);
5532    
5533     &vSendHTMLFooter;
5534    
5535     return;
5536    
5537     }
5538    
5539    
5540    
5541    
5542    
5543    
5544     #--------------------------------------------------------------------------
5545     #
5546     # Function: vSetSaveFolder()
5547     #
5548     # Purpose: This function saves that search and search name in a search file
5549     #
5550     # Called by:
5551     #
5552     # Parameters: void
5553     #
5554     # Global Variables: %main::ConfigurationData, %main::FormData,
5555     # $main::UserSettingsFilePath, $main::RemoteUser,
5556     #
5557     # Returns: void
5558     #
5559     sub vSetSaveFolder {
5560    
5561     my ($DocumentFolderFilePath, $HeaderName);
5562     my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
5563     my (@DocumentFolderList, $DocumentFolderEntry);
5564     my ($Document, %Document);
5565     my (%Value, @Values, $Value);
5566    
5567    
5568    
5569     # Return an error if the remote user name/account directory is not defined
5570     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5571     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5572     &vSendHTMLFooter;
5573     return;
5574     }
5575    
5576    
5577    
5578     # Make sure that we send the header
5579     &vSendHTMLHeader("Saving a Document Folder", undef);
5580     undef($Value);
5581     &vSendMenuBar(%Value);
5582    
5583    
5584     # Check that at least one document was selected
5585     if ( !defined($main::FormData{'Document'}) && !defined($main::FormData{'Documents'}) ) {
5586    
5587     print("<H3>Saving a Document Folder:</H3>\n");
5588     print("<H3><CENTER>Sorry, no document(s) were selected for saving.</CENTER></H3>\n");
5589     print("<P>\n");
5590     print("There needs to be a least one document selected in order to save it.\n");
5591     print("Click <B>'back'</B> on your browser, select at least one document and try again.\n");
5592    
5593     goto bailFromSetSaveFolder;
5594     }
5595    
5596    
5597     # Check that the required fields are filled in
5598     if ( !(defined($main::FormData{'FolderName'}) || defined($main::FormData{'DocumentFolderObject'})) ) {
5599    
5600     # A required field is missing, so we suggest corrective action to the user.
5601     print("<H3> Spremanje foldera s dokumentima: </H3>\n");
5602     print("<H3><CENTER> Oprostite, nedostaju neke informacije. </CENTER></H3>\n");
5603     print("<P>\n");
5604     print("Polje <B>'folder name'</B> mora biti ispunjeno da bi se mogao kreirati folder s dokumentima.<P>\n");
5605     print("Kliknite na <B>'Back'</B> u svom browseru, ispunite polje koje nedostaje i poku¹ajtwe ponovo.\n");
5606     print("<P>\n");
5607    
5608     goto bailFromSetSaveFolder;
5609     }
5610    
5611    
5612    
5613     # Check that the folder is there if we are saving to an existing folder
5614     if ( defined($main::FormData{'DocumentFolderObject'}) ) {
5615    
5616     # Check the old document folder if it is defined
5617     if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
5618    
5619     # Set the document folder file path
5620     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'FromDocumentFolderObject'};
5621    
5622     # Check to see if the old XML saved search file requested is there
5623     if ( ! -f $DocumentFolderFilePath ) {
5624     # Could not find the old saved search file
5625     &vHandleError("Saving a Document Folder", "Sorry, we cant to access this document folder object because it is not there");
5626     goto bailFromSetSaveFolder;
5627     }
5628    
5629     # Get information from the XML document folder file
5630     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
5631    
5632     # Check that the entry is valid
5633     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
5634     &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
5635     goto bailFromSetSaveFolder;
5636     }
5637     }
5638    
5639    
5640     # Set the document folder file path
5641     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
5642    
5643     # Check to see if the XML saved search file requested is there
5644     if ( ! -f $DocumentFolderFilePath ) {
5645     # Could not find the saved search file
5646     &vHandleError("Saving a Document Folder", "Sorry, we cant to access this document folder object because it is not there");
5647     goto bailFromSetSaveFolder;
5648     }
5649    
5650     # Get information from the XML document folder file
5651     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
5652    
5653     # Check that the entry is valid
5654     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
5655     &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
5656     goto bailFromSetSaveFolder;
5657     }
5658     }
5659     elsif ( defined($main::FormData{'FolderName'}) ) {
5660    
5661     # Get the document folder hash
5662     %Value = &hGetDocumentFolders;
5663    
5664     # Set the path/flag
5665     $DocumentFolderFilePath = $Value{$main::FormData{'FolderName'}};
5666    
5667     # Check that the document folder file does not already exist
5668     if ( defined($DocumentFolderFilePath) && !(defined($main::FormData{'OverWrite'}) && ($main::FormData{'OverWrite'} eq "yes")) ) {
5669    
5670     # There is already a document folder with this name, so we suggest corrective action to the user.
5671     print("<H3> Snimanje foldera s dokumentima: </H3>\n");
5672     print("<H3><CENTER> Oprostite, veæ postoji folder s tim imenom. </CENTER></H3>\n");
5673     print("<P>\n");
5674     print("Kliknite na <B>'Back'</B> u svom browseru, promijenite <B>'ime foldera'</B> i poku¹ate ponovo. \n");
5675     print("Alternativno, klikom na kvadratiæ, mo¾ete odabrati da ¾elite postojeæi folder zamijeniti ovim.\n");
5676     print("<P>\n");
5677    
5678     goto bailFromSetSaveFolder;
5679     }
5680     }
5681    
5682    
5683     # Save information in the folder
5684     if ( defined($main::FormData{'DocumentFolderObject'}) ) {
5685    
5686     # Get the data from the XML document folder file
5687     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
5688    
5689     # Check that the entry is valid
5690     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
5691     &vHandleError("Saving a Document Folder", "Sorry, this document folder object is invalid");
5692     goto bailFromGetSavedSearch;
5693     }
5694    
5695     $FolderName = $Value{'FolderName'};
5696     $FolderDescription = $Value{'FolderDescription'};
5697     $FolderDocuments = $Value{'FolderDocuments'};
5698     $CreationTime = $Value{'CreationTime'};
5699     $UpdateTime = time();
5700    
5701    
5702     # Merge the documents
5703     if ( defined($FolderDocuments) || defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
5704    
5705     # Undefine the hash table in preparation
5706     undef(%Value);
5707    
5708     # Make a hash table from the documents already in the document folder
5709     if ( defined($FolderDocuments) ) {
5710     foreach $Value ( split(/\0/, $FolderDocuments) ) {
5711     $Value{$Value} = $Value;
5712     }
5713     }
5714    
5715     # Add document that were specifically selected
5716     if ( defined($main::FormData{'Document'}) ) {
5717     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5718     $Value{$Value} = $Value;
5719     }
5720     }
5721     # Otherwise add documents that were selected by default
5722     elsif ( defined($main::FormData{'Documents'}) ) {
5723     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
5724     $Value{$Value} = $Value;
5725     }
5726     }
5727    
5728     # Assemble the new content
5729     $FolderDocuments = join("\0", keys(%Value));
5730    
5731     # Delete the old content
5732     delete($main::FormData{'Document'});
5733     delete($main::FormData{'Documents'});
5734     }
5735    
5736     }
5737     elsif ( defined($main::FormData{'FolderName'}) ) {
5738    
5739     $FolderName = $main::FormData{'FolderName'};
5740     $FolderDescription = $main::FormData{'FolderDescription'};
5741    
5742     # Merge the documents
5743     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) {
5744    
5745     # Undefine the hash table in preparation
5746     undef(%Value);
5747    
5748     # Add document that were specifically selected
5749     if ( defined($main::FormData{'Document'}) ) {
5750     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5751     $Value{$Value} = $Value;
5752     }
5753     }
5754     # Otherwise add documents that were selected by default
5755     elsif ( defined($main::FormData{'Documents'}) ) {
5756     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
5757     $Value{$Value} = $Value;
5758     }
5759     }
5760    
5761     # Assemble the new content
5762     $main::FormData{'Document'} = join("\0", keys(%Value));
5763    
5764     # Delete the old content
5765     delete($main::FormData{'Documents'});
5766     }
5767    
5768     $FolderDocuments = $main::FormData{'Document'};
5769     $CreationTime = time();
5770     $UpdateTime = time();
5771     }
5772    
5773    
5774     # Save the document folder to a new file
5775     if ( &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) ) {
5776    
5777     # Are we pulling these documents from an existing folder?
5778     if ( defined($main::FormData{'FromDocumentFolderObject'}) ) {
5779    
5780     # Set the document folder file path
5781     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'FromDocumentFolderObject'};
5782    
5783     # Get information from the XML document folder file
5784     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
5785    
5786    
5787     $FolderName = $Value{'FolderName'};
5788     $FolderDescription = $Value{'FolderDescription'};
5789     $FolderDocuments = $Value{'FolderDocuments'};
5790     $CreationTime = $Value{'CreationTime'};
5791     $UpdateTime = time();
5792    
5793    
5794     # Make a hash table from the documents selected for deletion, this serves as
5795     # a lookup table when we loop through the existing documents
5796     undef(%Value);
5797     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
5798     $Value{$Value} = 1;
5799     }
5800    
5801     # Parse out of the existing documents into a list
5802     foreach $Value ( split(/\0/, $FolderDocuments) ) {
5803     # Add the document if it is not on the deletion list
5804     if ( !defined($Value{$Value}) ) {
5805     push @Values, $Value;
5806     }
5807     }
5808     $FolderDocuments = join("\0", @Values);
5809    
5810    
5811     # Save the document folder
5812     &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
5813    
5814     }
5815    
5816     if ( defined($main::FormData{'MergeDocumentFolderObject'}) ) {
5817     @Values = split(/\0/, $main::FormData{'MergeDocumentFolderObject'});
5818     foreach $Value ( @Values ) {
5819     # Set the document folder file path
5820     if ( !(defined($main::FormData{'DocumentFolderObject'}) && ($main::FormData{'DocumentFolderObject'} eq $Value))) {
5821     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $Value;
5822     unlink($DocumentFolderFilePath);
5823     }
5824     }
5825     }
5826    
5827     print("<H3> Saving a Document Folder: </H3>\n");
5828     print("<P>\n");
5829     print("<H3><CENTER> Your document folder was successfully saved. </CENTER></H3>\n");
5830    
5831    
5832     }
5833     else {
5834    
5835     # The document folder could not be saved, so we inform the user of the fact
5836     &vHandleError("Saving a Document Folder", "Sorry, we failed to save this document folder");
5837     goto bailFromSetSaveFolder;
5838     }
5839    
5840    
5841     # Bail from saving the document folder
5842     bailFromSetSaveFolder:
5843    
5844     print("<CENTER><HR WIDTH=50%></CENTER>\n");
5845     undef(%Value);
5846     &vSendMenuBar(%Value);
5847    
5848     &vSendHTMLFooter;
5849    
5850     return;
5851    
5852     }
5853    
5854    
5855    
5856    
5857    
5858    
5859     #--------------------------------------------------------------------------
5860     #
5861     # Function: vListFolder()
5862     #
5863     # Purpose: This function allows the user list the document folders and
5864     # sets up the links allowing the user to get a list of the documents
5865     #
5866     # Called by:
5867     #
5868     # Parameters: void
5869     #
5870     # Global Variables: %main::ConfigurationData, %main::FormData,
5871     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
5872     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
5873     #
5874     # Returns: void
5875     #
5876     sub vListFolder {
5877    
5878     my (@DocumentFolderList, %QualifiedDocumentFolders, $DocumentFolderEntry, $HeaderName);
5879     my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
5880     my (@Values, $Value, %Value);
5881    
5882    
5883     # Return an error if the remote user name/account directory is not defined
5884     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
5885     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
5886     &vSendHTMLFooter;
5887     return;
5888     }
5889    
5890    
5891     # Make sure that we send the header
5892     &vSendHTMLHeader("Document Folders", undef);
5893     undef(%Value);
5894     $Value{'ListFolder'} = "ListFolder";
5895     &vSendMenuBar(%Value);
5896     undef(%Value);
5897    
5898    
5899    
5900     # Print out the document folders
5901 dpavlin 1.20 print("<H3> Korisnièki folderi: </H3>\n");
5902 dpavlin 1.1
5903    
5904     # Get the document folder hash
5905     %QualifiedDocumentFolders = &hGetDocumentFolders;
5906    
5907    
5908     # Print up the document folders, if there is none, we put up a nice message
5909     if ( scalar(keys(%QualifiedDocumentFolders)) > 0 ) {
5910    
5911     # Start the table
5912     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
5913    
5914     # Start the form
5915     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
5916    
5917    
5918     # Print the selector
5919     print("<TR><TD ALIGN=RIGHT VALIGN=TOP COLSPAN=3>\n");
5920     print("<SELECT NAME=\"Action\">\n");
5921     print("<OPTION VALUE=\"DeleteFolder\">Obri¹i oznaèene foldere\n");
5922     print("<OPTION VALUE=\"GetMergeFolder\">Spoji oznaèene foldere u novi folder\n");
5923    
5924     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
5925    
5926     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
5927    
5928     # Get the document folder file name and encode it
5929     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
5930     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
5931    
5932     print("<OPTION VALUE=\"SetMergeFolder&ToDocumentFolderObject=$DocumentFolderEntry\">Spoji oznaèene foldere u '$FolderName' folder\n");
5933     }
5934    
5935     print("</SELECT>\n");
5936     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
5937     print("</TD></TR>\n");
5938    
5939    
5940    
5941     # List the folders
5942     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
5943    
5944     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=3><HR WIDTH=50%></TD></TR>\n");
5945    
5946     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
5947    
5948     # Get information from the XML document folder file
5949     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderEntry);
5950    
5951     # Get the saved search file name and encode it
5952     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
5953     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
5954    
5955    
5956     $FolderName = $Value{'FolderName'};
5957     $FolderDescription = $Value{'FolderDescription'};
5958     $FolderDocuments = $Value{'FolderDocuments'};
5959     $CreationTime = $Value{'CreationTime'};
5960     $UpdateTime = $Value{'UpdateTime'};
5961    
5962    
5963     # Print the link
5964     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");
5965    
5966     # Print the folder description
5967     $FolderDescription = defined($FolderDescription) ? $FolderDescription : "(Nije naveden)";
5968     $FolderDescription =~ s/\n/<BR>/g;
5969     $FolderDescription =~ s/\r/<BR>/g;
5970     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $FolderDescription </TD></TR>\n");
5971    
5972     if ( defined($FolderDocuments) ) {
5973     @Values = split(/\0/, $FolderDocuments);
5974     $Value = scalar( @Values );
5975     }
5976     else {
5977     $Value = 0;
5978     }
5979     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Broj rezultata: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5980    
5981    
5982     $Value = &sGetPrintableDateFromTime($CreationTime);
5983     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5984    
5985     $Value = &sGetPrintableDateFromTime($UpdateTime);
5986     print("<TR><TD WIDTH=1%></TD><TD ALIGN=LEFT VALIGN=TOP> Datum zadnje promijene: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
5987    
5988     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");
5989     }
5990    
5991     print("</FORM></TABLE>\n");
5992     }
5993     else {
5994     print("<H3><CENTER> Nema foldera! </CENTER></H3>\n");
5995     }
5996    
5997    
5998    
5999    
6000     # Bail from displaying document folders
6001     bailFromListFolder:
6002    
6003     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6004     undef(%Value);
6005     $Value{'ListFolder'} = "ListFolder";
6006     &vSendMenuBar(%Value);
6007     undef(%Value);
6008    
6009     &vSendHTMLFooter;
6010    
6011    
6012     return;
6013    
6014     }
6015    
6016    
6017    
6018    
6019    
6020    
6021     #--------------------------------------------------------------------------
6022     #
6023     # Function: vMergeFolder()
6024     #
6025     # Purpose: This function deletes a folder.
6026     #
6027     # Called by:
6028     #
6029     # Parameters: void
6030     #
6031     # Global Variables: %main::ConfigurationData, %main::FormData,
6032     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
6033     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
6034     #
6035     # Returns: void
6036     #
6037     sub vMergeFolder {
6038    
6039     my ($Title, $HeaderName, $DocumentFolderFilePath, $DocumentFolderObject, $FolderDocuments);
6040     my ($Value, %Value);
6041    
6042    
6043    
6044     # Return an error if the remote user name/account directory is not defined
6045     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6046     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6047     &vSendHTMLFooter;
6048     return;
6049     }
6050    
6051    
6052    
6053     # Check to see if the document folder object is defined
6054     if ( ! defined($main::FormData{'DocumentFolderObject'}) ) {
6055    
6056     # Could not find the document folder file
6057     &vSendHTMLHeader("Merge Document Folders", undef);
6058     undef(%Value);
6059     &vSendMenuBar(%Value);
6060     print("<H3> Merge Document Folders: </H3>\n");
6061     print("<H3><CENTER> Sorry, no document folders were selected. </CENTER></H3>\n");
6062     print("<P>\n");
6063     print("You need to select at least one document folder in order to be able to perform an action on it.\n");
6064     print("<P>\n");
6065     return;
6066     }
6067    
6068    
6069     # Init the value hash
6070     undef(%Value);
6071    
6072     # Loop over document folder object
6073     $Value = $main::FormData{'DocumentFolderObject'} .
6074     ((defined($main::FormData{'ToDocumentFolderObject'})) ? "\0" . $main::FormData{'ToDocumentFolderObject'} : "");
6075    
6076     foreach $DocumentFolderObject ( split(/\0/, $Value) ) {
6077    
6078     # Set the document folder file path
6079     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $DocumentFolderObject;
6080    
6081     # Check to see if the XML saved search file requested is there
6082     if ( ! -f $DocumentFolderFilePath ) {
6083     next;
6084     }
6085    
6086     # Get information from the XML saved search file
6087     $HeaderName = &sGetObjectTagFromXMLFile($DocumentFolderFilePath);
6088    
6089     # Check that the entry is valid
6090     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6091     next;
6092     }
6093    
6094     # Get the FolderDocuments symbol
6095     $FolderDocuments = &sGetTagValueFromXMLFile($DocumentFolderFilePath, "FolderDocuments");
6096    
6097     # Add each document to the hash
6098     foreach $Value ( split(/\0/, $FolderDocuments) ) {
6099     $Value{$Value} = $Value;
6100     }
6101     }
6102    
6103     # Set the document URL from the hash
6104     $main::FormData{'Document'} = join("\0", keys(%Value));
6105    
6106    
6107     if ( defined($main::FormData{'DocumentFolderObject'}) ) {
6108     $main::FormData{'MergeDocumentFolderObject'} = $main::FormData{'DocumentFolderObject'};
6109     delete($main::FormData{'DocumentFolderObject'});
6110     }
6111    
6112     if ( defined($main::FormData{'ToDocumentFolderObject'}) ) {
6113     $main::FormData{'DocumentFolderObject'} = $main::FormData{'ToDocumentFolderObject'};
6114     delete($main::FormData{'ToDocumentFolderObject'});
6115     }
6116    
6117    
6118     if ( $ENV{'PATH_INFO'} eq "/GetMergeFolder" ) {
6119     &vGetSaveFolder;
6120     }
6121     elsif ( $ENV{'PATH_INFO'} eq "/SetMergeFolder" ) {
6122     &vSetSaveFolder;
6123     }
6124    
6125    
6126     return;
6127    
6128     }
6129    
6130    
6131    
6132    
6133    
6134    
6135     #--------------------------------------------------------------------------
6136     #
6137     # Function: vProcessFolder()
6138     #
6139     # Purpose: This function deletes a folder.
6140     #
6141     # Called by:
6142     #
6143     # Parameters: void
6144     #
6145     # Global Variables: %main::ConfigurationData, %main::FormData,
6146     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
6147     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
6148     #
6149     # Returns: void
6150     #
6151     sub vProcessFolder {
6152    
6153     my ($Title, $HeaderName, $DocumentFolderFilePath, $DocumentFolderObject);
6154     my ($Value, %Value);
6155    
6156    
6157    
6158     # Return an error if the remote user name/account directory is not defined
6159     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6160     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6161     &vSendHTMLFooter;
6162     return;
6163     }
6164    
6165    
6166    
6167     if ( $ENV{'PATH_INFO'} eq "/DeleteFolder" ) {
6168     $Title = "Delete Document Folders";
6169     }
6170    
6171    
6172     # Make sure that we send the header
6173     &vSendHTMLHeader($Title, undef);
6174     undef(%Value);
6175     &vSendMenuBar(%Value);
6176    
6177     print("<H3> $Title: </H3>\n");
6178    
6179     # Check to see if the document folder object is defined
6180     if ( ! defined($main::FormData{'DocumentFolderObject'}) ) {
6181    
6182     # Could not find the document folder file
6183     print("<H3><CENTER> Sorry, no document folders were selected. </CENTER></H3>\n");
6184     print("<P>\n");
6185     print("You need to select at least one document folder in order to be able to perform an action on it.\n");
6186     print("<P>\n");
6187    
6188     goto bailFromProcessFolder;
6189     }
6190    
6191    
6192     # Loop over document folder object
6193     foreach $DocumentFolderObject ( split(/\0/, $main::FormData{'DocumentFolderObject'}) ) {
6194    
6195     # Set the document folder file path
6196     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $DocumentFolderObject;
6197    
6198     # Check to see if the XML saved search file requested is there
6199     if ( ! -f $DocumentFolderFilePath ) {
6200     printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
6201     next;
6202     }
6203    
6204     # Get information from the XML saved search file
6205     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
6206    
6207     # Check that the entry is valid
6208     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6209     printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
6210     }
6211    
6212    
6213     if ( unlink($DocumentFolderFilePath) ) {
6214     printf("<P>Successfully deleted: %s\n", $Value{'FolderName'});
6215     }
6216     else {
6217     printf("<P>Failed to delete: %s\n", $Value{'FolderName'});
6218     }
6219     }
6220    
6221     print("<P>\n");
6222    
6223     # Bail from processing the document folder
6224     bailFromProcessFolder:
6225    
6226     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6227     undef(%Value);
6228     &vSendMenuBar(%Value);
6229    
6230     &vSendHTMLFooter;
6231    
6232     return;
6233    
6234     }
6235    
6236    
6237    
6238    
6239    
6240    
6241     #--------------------------------------------------------------------------
6242     #
6243     # Function: vGetFolder()
6244     #
6245     # Purpose: This function displays a document folder to the user.
6246     #
6247     # Called by:
6248     #
6249     # Parameters: void
6250     #
6251     # Global Variables: %main::ConfigurationData, %main::FormData,
6252     # $main::UserAccountDirectoryPath, $main::XMLFileNameExtension,
6253     # $main::DocumentFolderFileNamePrefix, $main::RemoteUser
6254     #
6255     # Returns: void
6256     #
6257     sub vGetFolder {
6258    
6259     my ($HeaderName, $FolderName, $SelectorText, %ArticleFolder);
6260     my (@DocumentFolderList, $DocumentFolderEntry, %QualifiedDocumentFolders);
6261     my ($Value, %Value);
6262    
6263    
6264     # Return an error if the remote user name/account directory is not defined
6265     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6266     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6267     &vSendHTMLFooter;
6268     return;
6269     }
6270    
6271    
6272    
6273     # Make the document folder file name
6274     $DocumentFolderEntry = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
6275    
6276     # Check to see if the XML document folder file requested is there
6277     if ( ! -f $DocumentFolderEntry ) {
6278     # Could not find the document folders file
6279     &vHandleError("Document Folder", "Sorry, we cant to access this document folder object because it is not there");
6280     goto bailFromGetFolder;
6281     }
6282    
6283     # Get information from the XML document folder file
6284     ($HeaderName, %ArticleFolder) = &shGetHashFromXMLFile($DocumentFolderEntry);
6285    
6286     # Check that the entry is valid
6287     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6288     &vHandleError("Document Folder", "Sorry, this document folder object is invalid");
6289     goto bailFromGetFolder;
6290     }
6291    
6292    
6293     # Make sure we send the header
6294     &vSendHTMLHeader("Document Folder", undef);
6295     undef(%Value);
6296     &vSendMenuBar(%Value);
6297    
6298     print("<H3> Document Folder: </H3>\n");
6299    
6300    
6301     # Start the form
6302     print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}\" METHOD=POST>\n");
6303    
6304    
6305     # Print the selector if there are any documents
6306     if ( defined($ArticleFolder{'FolderDocuments'}) ) {
6307     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
6308     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");
6309     print("<SELECT NAME=\"Action\">\n");
6310     print("<OPTION VALUE=\"GetDocument\">Prika¾i odabrane rezultates\n");
6311     if ( $main::ConfigurationData{'allow-similiar-search'} eq "yes" ) {
6312     print("<OPTION VALUE=\"GetSimilarDocument\">Prika¾i rezultate sliène odabranim rezultatima\n");
6313     }
6314     if ( $main::ConfigurationData{'allow-relevance-feedback-searches'} eq "yes" ) {
6315     print("<OPTION VALUE=\"GetSearchResults\">Run search with selected documents as relevance feedback\n");
6316     }
6317     print("<OPTION VALUE=\"DeleteDocument&DocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Delete selected documents from this document folder\n");
6318     print("<OPTION VALUE=\"GetSaveFolder&FromDocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Move selected documents to a new document folder\n");
6319    
6320    
6321     # Get the document folder hash
6322     %QualifiedDocumentFolders = &hGetDocumentFolders;
6323    
6324     for $FolderName ( sort( keys(%QualifiedDocumentFolders)) ) {
6325    
6326     # Skip this folder
6327     if ( $FolderName eq $ArticleFolder{'FolderName'} ) {
6328     next;
6329     }
6330    
6331     $DocumentFolderEntry = $QualifiedDocumentFolders{$FolderName};
6332    
6333     # Get the document folder file name and encode it
6334     $DocumentFolderEntry = ($DocumentFolderEntry =~ /^$main::UserAccountDirectoryPath\/(.*)/) ? $1 : $DocumentFolderEntry;
6335     $DocumentFolderEntry = &lEncodeURLData($DocumentFolderEntry);
6336    
6337     print("<OPTION VALUE=\"SetSaveFolder&DocumentFolderObject=$DocumentFolderEntry&FromDocumentFolderObject=$main::FormData{'DocumentFolderObject'}\">Move selected documents to the '$FolderName' document folder\n");
6338     }
6339    
6340     print("</SELECT>\n");
6341     print("<INPUT TYPE=SUBMIT VALUE=\"Do It!\">\n");
6342     print("</TD></TR>\n");
6343     print("</TABLE>\n");
6344     }
6345    
6346     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6347    
6348    
6349     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0 WIDTH=100%>\n");
6350    
6351     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Naziv: </TD> <TD ALIGN=LEFT VALIGN=TOP> $ArticleFolder{'FolderName'} </TD></TR>\n");
6352    
6353     # Print the folder description
6354     $ArticleFolder{'FolderDescription'} = defined($ArticleFolder{'FolderDescription'}) ? $ArticleFolder{'FolderDescription'} : "(No description defined)";
6355     $ArticleFolder{'FolderDescription'} =~ s/\n/<BR>/g;
6356     $ArticleFolder{'FolderDescription'} =~ s/\r/<BR>/g;
6357     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Opis: </TD> <TD ALIGN=LEFT VALIGN=TOP> $ArticleFolder{'FolderDescription'} </TD></TR>\n");
6358    
6359    
6360     $Value = &sGetPrintableDateFromTime($ArticleFolder{'CreationTime'});
6361     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum kreiranja: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
6362    
6363     $Value = &sGetPrintableDateFromTime($ArticleFolder{'UpdateTime'});
6364     print("<TR><TD ALIGN=LEFT VALIGN=TOP> Datum zadnje promijene: </TD> <TD ALIGN=LEFT VALIGN=TOP> $Value </TD></TR>\n");
6365    
6366     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2><HR WIDTH=50%></TD></TR>\n");
6367    
6368    
6369     # Display a button to select all the documents if there are any
6370     if ( defined($ArticleFolder{'FolderDocuments'}) ) {
6371    
6372     $SelectorText = "";
6373    
6374     # Loop over each entry folder documents
6375     foreach $Value ( split(/\0/, $ArticleFolder{'FolderDocuments'}) ) {
6376     $SelectorText .= (($SelectorText ne "") ? "|" : "") . $Value;
6377     }
6378    
6379     $SelectorText = "<INPUT TYPE=\"HIDDEN\" NAME=\"Documents\" VALUE=\"" . $SelectorText . "\"> ";
6380     print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> $SelectorText </TD></TR>\n");
6381     }
6382    
6383     if ( defined($ArticleFolder{'FolderDocuments'}) ) {
6384     print("<TR>\n");
6385     &bDisplayDocuments("Document", $ArticleFolder{'FolderDocuments'}, "Document", 1, undef, 1);
6386     print("</TR>\n");
6387     }
6388     else {
6389     print("<TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=2> This document folder does not contain any documents. </TD></TR>\n");
6390     }
6391    
6392     print("</FORM></TABLE>\n");
6393    
6394     # Bail from displaying the document folder
6395     bailFromGetFolder:
6396    
6397     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6398     undef(%Value);
6399     &vSendMenuBar(%Value);
6400    
6401     &vSendHTMLFooter;
6402    
6403     return;
6404    
6405     }
6406    
6407    
6408    
6409    
6410    
6411    
6412     #--------------------------------------------------------------------------
6413     #
6414     # Function: vProcessDocument()
6415     #
6416     # Purpose: This function deletes folder documents
6417     #
6418     # Called by:
6419     #
6420     # Parameters: void
6421     #
6422     # Global Variables: %main::ConfigurationData, %main::FormData,
6423     # $main::UserSettingsFilePath, $main::RemoteUser,
6424     #
6425     # Returns: void
6426     #
6427     sub vProcessDocument {
6428    
6429     my ($Title, $DocumentFolderFilePath, $HeaderName);
6430     my ($FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime);
6431     my (%Value, @Values, $Value);
6432    
6433    
6434    
6435     # Return an error if the remote user name/account directory is not defined
6436     if ( ! (defined($main::RemoteUser) && defined($main::UserAccountDirectoryPath)) ) {
6437     &vHandleError("Undefined User Account", "Sorry, there is no user account defined");
6438     &vSendHTMLFooter;
6439     return;
6440     }
6441    
6442    
6443     # Check to see if the XML document folder is there
6444     if ( !defined($main::FormData{'DocumentFolderObject'}) ) {
6445     # Could not find the document folders file
6446     &vHandleError($Title, "Sorry, the document folder object was not defined");
6447     goto bailFromProcessDocument;
6448     }
6449    
6450    
6451     # Set the title
6452     if ( $ENV{'PATH_INFO'} eq "/DeleteDocument" ) {
6453     $Title = "Delete Folder Documents";
6454     }
6455    
6456    
6457     # Make sure that we send the header
6458     &vSendHTMLHeader($Title, undef);
6459     undef(%Value);
6460     &vSendMenuBar(%Value);
6461    
6462    
6463    
6464     # Check to see if the document folder object is defined
6465     if ( ! (defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'})) ) {
6466    
6467     # No documents were defined
6468     print("<H3><CENTER> Sorry, no documents were selected. </CENTER></H3>\n");
6469     print("<P>\n");
6470     print("You need to select at least one document in order to be able to perform an action on it.\n");
6471     print("<P>\n");
6472    
6473     goto bailFromProcessDocument;
6474     }
6475    
6476    
6477     # Set the document folder file path
6478     $DocumentFolderFilePath = $main::UserAccountDirectoryPath . "/" . $main::FormData{'DocumentFolderObject'};
6479    
6480    
6481     # Check to see if the XML document folder file requested is there
6482     if ( ! -f $DocumentFolderFilePath ) {
6483     # Could not find the document folders file
6484     &vHandleError($Title, "Sorry, we cant to access this document folder object because it is not there");
6485     goto bailFromProcessDocument;
6486     }
6487    
6488    
6489     # Get information from the XML document folder file
6490     ($HeaderName, %Value) = &shGetHashFromXMLFile($DocumentFolderFilePath);
6491    
6492     # Check that the entry is valid
6493     if ( !(defined($HeaderName) && ($HeaderName eq "DocumentFolder")) ) {
6494     &vHandleError($Title, "Sorry, this document folder object is invalid");
6495     goto bailFromProcessDocument;
6496     }
6497    
6498    
6499    
6500     $FolderName = $Value{'FolderName'};
6501     $FolderDescription = $Value{'FolderDescription'};
6502     $FolderDocuments = $Value{'FolderDocuments'};
6503     $CreationTime = $Value{'CreationTime'};
6504     $UpdateTime = time();
6505    
6506    
6507     # Make a hash table from the documents selected for deletion, this serves as
6508     # a lookup table when we loop through the existing documents
6509     # List the documents
6510     if ( defined($main::FormData{'Document'}) || defined($main::FormData{'Documents'}) ) {
6511    
6512     # Undefine the hash table in preparation
6513     undef(%Value);
6514    
6515     # Add document that were specifically selected
6516     if ( defined($main::FormData{'Document'}) ) {
6517     foreach $Value ( split(/\0/, $main::FormData{'Document'}) ) {
6518     $Value{$Value} = $Value;
6519     }
6520     }
6521     # Otherwise add documents that were selected by default
6522     elsif ( defined($main::FormData{'Documents'}) ) {
6523     foreach $Value ( split(/\|/, $main::FormData{'Documents'}) ) {
6524     $Value{$Value} = $Value;
6525     }
6526     }
6527     }
6528    
6529    
6530     # Parse out of the existing documents into a list
6531     foreach $Value ( split(/\0/, $FolderDocuments) ) {
6532     # Add the document if it is not on the deletion list
6533     if ( !defined($Value{$Value}) ) {
6534     push @Values, $Value;
6535     }
6536     }
6537     $FolderDocuments = join("\0", @Values);
6538    
6539    
6540     # Save the document folder (now missing the selected documents)
6541     if ( &iSaveFolder($DocumentFolderFilePath, $FolderName, $FolderDescription, $FolderDocuments, $CreationTime, $UpdateTime) ) {
6542    
6543     print("<H3> $Title: </H3>\n");
6544     print("<P>\n");
6545     print("<H3><CENTER> The folder documents were successfully deleted. </CENTER></H3>\n");
6546    
6547     }
6548     else {
6549    
6550     # The documents coudl not be deleted, so we inform the user of the fact
6551     &vHandleError($Title, "Sorry, we failed to delete the selected folder documents");
6552     goto bailFromProcessDocument;
6553     }
6554    
6555    
6556     # Bail from deleting the documents
6557     bailFromProcessDocument:
6558    
6559     print("<CENTER><HR WIDTH=50%></CENTER>\n");
6560     undef(%Value);
6561     &vSendMenuBar(%Value);
6562    
6563     &vSendHTMLFooter;
6564    
6565     return;
6566    
6567     }
6568    
6569    
6570    
6571    
6572    
6573    
6574     #--------------------------------------------------------------------------
6575     #
6576     # Function: vRunSavedSearches()
6577     #
6578     # Purpose: Run the saved searches which are due
6579     #
6580     # Called by:
6581     #
6582     # Parameters: $PassedFrequency search frequency
6583     #
6584     # Global Variables:
6585     #
6586     # Returns: void
6587     #
6588     sub vRunSavedSearches {
6589    
6590     my ($PassedFrequency) = @_;
6591     my (@UserAccountsDirectoryList, $UserAccountsDirectory, @UserSavedSearchList, $UserSavedSearch);
6592     my (@SavedSearchFilePathList, @QualifiedSaveSearchFilePathList, $SavedSearchFilePath);
6593     my ($SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchString, $DeliveryFormat, $DeliveryMethod, $SearchFrequency, $SearchStatus, $CreationTime, $LastRunTime);
6594     my ($EmailAddress, $NewLastRunTime, $Databases, $HeaderName);
6595     my ($Status, $SearchResults, $FinalSearchString, $SearchResult, $ResultCount, $QueryReport, $ErrorNumber, $ErrorMessage);
6596     my ($ItemName, $MimeType, $HTML, $SavedFileHandle);
6597     my ($Value, %Value, $ValueEntry);
6598    
6599    
6600     # Check that we can actually run saved searches
6601     if ( !(defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes")) ) {
6602     print("Execution error - configuration setting: 'allow-regular-searches', setting not set or disabled.\n");
6603     return;
6604     }
6605    
6606    
6607     # Check that we have a user account directory
6608     if ( !defined($main::ConfigurationData{'user-accounts-directory'}) ) {
6609     print("Execution error - configuration setting: 'user-accounts-directory', setting not set.\n");
6610     }
6611    
6612    
6613     # Check that we have a script URL
6614     if ( !(defined($main::ConfigurationData{'script-url'}) && ($main::ConfigurationData{'script-url'} ne "yes")) ) {
6615     print("Execution error - configuration setting: 'script-url', setting not set.\n");
6616     }
6617    
6618    
6619     # Scoop up all the directories in the user accounts directory
6620     opendir(ACCOUNTS_DIRECTORY, $main::ConfigurationData{'user-accounts-directory'});
6621     @UserAccountsDirectoryList = grep(!/^\.\.?$/, readdir(ACCOUNTS_DIRECTORY));
6622     closedir(ACCOUNTS_DIRECTORY);
6623    
6624     # Loop over each user account
6625     foreach $UserAccountsDirectory ( @UserAccountsDirectoryList ) {
6626    
6627     # Read all the saved searches
6628     opendir(USER_ACCOUNT_DIRECTORY, $main::ConfigurationData{'user-accounts-directory'} . "/" . $UserAccountsDirectory);
6629     @UserSavedSearchList = grep(/$main::SavedSearchFileNamePrefix/, readdir(USER_ACCOUNT_DIRECTORY));
6630     closedir(USER_ACCOUNT_DIRECTORY);
6631    
6632     # And add each to the saved searches list
6633     foreach $UserSavedSearch ( @UserSavedSearchList ) {
6634     push @SavedSearchFilePathList, $main::ConfigurationData{'user-accounts-directory'} . "/" . $UserAccountsDirectory . "/" . $UserSavedSearch;
6635     }
6636     }
6637    
6638    
6639     # Return here if there are no saved search to process
6640     if ( ! @SavedSearchFilePathList ) {
6641     print("Execution warning - no saved searches to process.\n");
6642     return;
6643     }
6644    
6645    
6646     # Loop over each file in the list, checking to see if it is time to
6647     # process this one, if so we add it to the qualified saved search list
6648     foreach $SavedSearchFilePath ( @SavedSearchFilePathList ) {
6649    
6650     # Get the header name from the saved search file
6651     $HeaderName = &sGetObjectTagFromXMLFile($SavedSearchFilePath);
6652    
6653     # Skip this saved search file entry if it is not valid
6654     if ( !(defined($HeaderName) && ($HeaderName eq "SavedSearch")) ) {
6655     print("Execution error - invalid saved search object: '$SavedSearchFilePath'.\n");
6656     next;
6657     }
6658    
6659    
6660     # Get the delivery format from the saved search file
6661     $DeliveryFormat = &sGetTagValueFromXMLFile($SavedSearchFilePath, "DeliveryFormat");
6662    
6663     # Check the delivery format, it is undefined if the search is not a regular search
6664     if ( ! defined($DeliveryFormat) ) {
6665     next;
6666     }
6667    
6668     # Check the validity of the delivery format
6669     if ( ! defined($main::DeliveryFormats{$DeliveryFormat}) ) {
6670     print("Execution error - invalid delivery method: '$DeliveryFormat' in saved search: '$SavedSearchFilePath'.\n");
6671     next;
6672     }
6673    
6674    
6675    
6676     # Set the user settings file path name
6677     $main::UserSettingsFilePath = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/") + 1) . $main::UserSettingsFileName . $main::XMLFileNameExtension;
6678    
6679     # Check that this preference file is valid
6680     $HeaderName = &sGetObjectTagFromXMLFile($main::UserSettingsFilePath);
6681    
6682     # Skip this entry if it is not valid
6683     if ( !(defined($HeaderName) && ($HeaderName eq "UserSettings")) ) {
6684     print("Execution error - invalid user settings object: '$main::UserSettingsFilePath'.\n");
6685     next;
6686     }
6687    
6688    
6689     # Get the email address from the user settings file
6690     $EmailAddress = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
6691    
6692     # Skip this entry if it is not valid
6693     if ( !defined($EmailAddress) ) {
6694     print("Execution error - invalid email address in user settings object: '$main::UserSettingsFilePath'.\n");
6695     next;
6696     }
6697    
6698    
6699     # Get the frequency requested for this saved search
6700     $SearchFrequency = &sGetTagValueFromXMLFile($SavedSearchFilePath, "SearchFrequency");
6701    
6702     # Check the search frequency, skip if it is undefined
6703     if ( !defined($SearchFrequency)) {
6704     print("Execution error - undefined search frequency in user settings object: '$main::UserSettingsFilePath'.\n");
6705     next;
6706     }
6707    
6708     # Check the search frequency, skip if it is invalid
6709     $Value = 0;
6710     foreach $ValueEntry ( @main::SearchFrequencies ) {
6711     if ( $ValueEntry eq $SearchFrequency ) {
6712     $Value = 1;
6713     last;
6714     }
6715     }
6716     if ( !$Value ) {
6717     print("Execution error - invalid search frequency: '$SearchFrequency', in user settings object: '$main::UserSettingsFilePath'.\n");
6718     next;
6719     }
6720    
6721    
6722     # Is this the frequency we are currently working on?
6723     if ( index($PassedFrequency, $SearchFrequency) < 0 ) {
6724     next;
6725     }
6726    
6727    
6728     # It is, so we concatenate the saved search file name to the list of
6729     # qualified saved search file names
6730     push @QualifiedSaveSearchFilePathList, $SavedSearchFilePath;
6731     }
6732    
6733    
6734    
6735     # Return here if there are no qualified saved search to process
6736     if ( ! @QualifiedSaveSearchFilePathList ) {
6737     return;
6738     }
6739    
6740    
6741     # Get the current time, this will be used as the new last run time
6742     $NewLastRunTime = time();
6743    
6744    
6745     # Loop each saved search in the qualified saved search list, processing each of them
6746     foreach $SavedSearchFilePath ( @QualifiedSaveSearchFilePathList ) {
6747    
6748     # Get information from the XML saved search file
6749     ($HeaderName, %Value) = &shGetHashFromXMLFile($SavedSearchFilePath);
6750    
6751     $SearchName = $Value{'SearchName'};
6752     $SearchDescription = $Value{'SearchDescription'};
6753     $SearchString = $Value{'SearchString'};
6754     $SearchAndRfDocumentURL = $Value{'SearchAndRfDocumentURL'};
6755     $SearchFrequency = $Value{'SearchFrequency'};
6756     $SearchStatus = $Value{'SearchStatus'};
6757     $DeliveryFormat = $Value{'DeliveryFormat'};
6758     $DeliveryMethod = $Value{'DeliveryMethod'};
6759     $CreationTime = $Value{'CreationTime'};
6760     $LastRunTime = $Value{'LastRunTime'};
6761    
6762    
6763     # Check the search status, run the search if it is active
6764     if ( defined($SearchStatus) && ($SearchStatus eq "Active") ) {
6765    
6766     # Get the last run time from the XML saved search file
6767     if ( !defined($LastRunTime) ) {
6768     $LastRunTime = "0";
6769     }
6770    
6771    
6772     # Set the remote user name
6773     $main::RemoteUser = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/"));
6774     $main::RemoteUser = substr($main::RemoteUser, rindex($main::RemoteUser,"/") + 1);
6775    
6776     # Set the user directory path
6777     $main::UserAccountDirectoryPath = substr($SavedSearchFilePath, 0, rindex($SavedSearchFilePath,"/") + 1);
6778    
6779     # Set the user settings file path name
6780     $main::UserSettingsFilePath = $main::UserAccountDirectoryPath . $main::UserSettingsFileName . $main::XMLFileNameExtension;
6781    
6782     # Get the email address from the user settings file
6783     $EmailAddress = &sGetTagValueFromXMLFile($main::UserSettingsFilePath, "EmailAddress");
6784    
6785     # Parse the URL search string into the form data global
6786     %main::FormData = &hParseURLIntoHashTable($SearchAndRfDocumentURL);
6787    
6788    
6789     ##########################
6790     # Uncomment this to force a check over the complete database rather than
6791     # just getting the documents which changed since the last run
6792     # $LastRunTime = 0;
6793     ##########################
6794    
6795    
6796     # Clear the date restriction fields, they are meaningless in this context
6797     delete($main::FormData{'Since'});
6798     delete($main::FormData{'Before'});
6799    
6800     # Set the last run time restriction
6801     $main::FormData{'LastRunTime'} = $LastRunTime;
6802    
6803    
6804     # Generate the search string
6805     $FinalSearchString = &sMakeSearchString(%main::FormData);
6806    
6807    
6808     # Set the local database names
6809     if ( defined($main::FormData{'Database'}) ) {
6810    
6811     # Set the database variable and convert all the '\0' to ','
6812     $Databases = $main::FormData{'Database'};
6813     $Databases =~ tr/\0/,/;
6814     }
6815    
6816    
6817    
6818     print("Execution - saved search: '$SavedSearchFilePath', database: '$Databases', search: '$FinalSearchString', time: '$LastRunTime'.\n");
6819    
6820     # Run the search
6821     ($Status, $SearchResults) = MPS::SearchDatabase($main::MPSSession, $Databases, $FinalSearchString, "", 0, $main::DefaultMaxDoc - 1, $main::ConfigurationData{'max-score'});
6822    
6823     if ( ! $Status ) {
6824     ($ErrorNumber, $ErrorMessage) = split(/\t/, $SearchResults, 2);
6825     print("Execution error - failed to run the search.\n");
6826     print("The following error message was reported: <BR>\n");
6827     print("Error Message: $ErrorMessage <BR>\n");
6828     print("Error Number: $ErrorNumber <BR>\n");
6829     next;
6830     }
6831    
6832    
6833     # Get the number of results we got from the search
6834     $ResultCount = 0;
6835     foreach $SearchResult ( split(/\n/, $SearchResults) ) {
6836    
6837     # Parse the headline, also get the first document item/type
6838     (undef, undef, undef, undef, undef undef, $ItemName, $MimeType, undef) = split(/\t/, $SearchResult, 9);
6839    
6840     # Is this a query report
6841     if ( !(($ItemName eq $main::QueryReportItemName) && ($MimeType eq $main::QueryReportMimeType)) ) {
6842     # Increment the result count
6843     $ResultCount++;
6844     }
6845     }
6846    
6847    
6848     # Do we want to deliver email messages with no new results?
6849     if ( defined($main::ConfigurationData{'deliver-empty-results-from-regular-search'}) && ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} eq "no") ) {
6850     if ( $ResultCount == 0 ) {
6851     next;
6852     }
6853     }
6854    
6855    
6856     # Open the mail application, put put an error message if we cant open it and loop to the next saved search
6857     if ( ! open(RESULT_FILE, "| $main::ConfigurationData{'mailer-application'} $EmailAddress ") ) {
6858     print("Execution error - failed to launch mail application: '$main::ConfigurationData{'mailer-application'}', system error: $!.\n");
6859     next;
6860     }
6861    
6862    
6863     # Save the file handle for stdout and select the result file handle as the default handle
6864     $SavedFileHandle = select;
6865     select RESULT_FILE;
6866    
6867    
6868     # Print out the message header (To:)
6869     print ("To: $EmailAddress\n");
6870    
6871     # Print out the message header (From:)
6872     if ( defined($main::ConfigurationData{'site-admin-email'}) && ($main::ConfigurationData{'site-admin-email'} ne "") ) {
6873     print ("From: $main::ConfigurationData{'site-admin-email'}\n");
6874     }
6875    
6876     # Print out the message header (Subject:)
6877     print ("Subject: Results for saved search: $SearchName\n");
6878    
6879    
6880     # Print out the message header (Content-Type)
6881     if ( $DeliveryMethod eq "attachement" ) {
6882     print("Mime-Version: 1.0\n");
6883     print("Content-Type: multipart/mixed; boundary=\"============_-1234567890==_============\"\n");
6884     }
6885     else {
6886     print("Mime-Version: 1.0\n");
6887     printf("Content-Type: %s\n\n", ($DeliveryFormat eq "text/html") ? "text/html" : "text/plain");
6888     }
6889    
6890     # Print out the separating new line between message header and message body
6891     print("\n");
6892    
6893    
6894    
6895     # Print out mime part separator and mime header for the message header
6896     if ( $DeliveryMethod eq "attachement" ) {
6897     print("--============_-1234567890==_============\n");
6898     printf("Content-Type: text/plain; charset=\"us-ascii\"\n\n\n");
6899    
6900     if ( $DeliveryFormat eq "text/plain" ) {
6901     print("The search results are attached to this email message as a plain text\n");
6902     print("file. This file can be opened with a any word processor or text editor.\n");
6903     }
6904     elsif ( $DeliveryFormat eq "text/html" ) {
6905     print("The search results are attached to this email message as an HTML\n");
6906     print("file. This file can be opened with Netscape or Internet Explorer.\n");
6907     }
6908    
6909     print("--============_-1234567890==_============\n");
6910     $Value = "citations." . (($DeliveryFormat eq "text/html") ? "html" : "txt");
6911     print("Content-Type: $DeliveryFormat; name=\"$Value\"\n");
6912     print("Content-Disposition: attachment; filename=\"$Value\"\n\n");
6913     }
6914    
6915    
6916     # Get the current date
6917     $Value = &sGetPrintableDateFromTime();
6918    
6919     # Set the HTML flag
6920     $HTML = ( $DeliveryFormat eq "text/html" ) ? 1 : 0;
6921    
6922     # Write out the search result header
6923     ($Status, $QueryReport) = &bsDisplaySearchResults("Search Results for: $SearchName:", $SearchDescription, $Value, $SearchFrequency, $SearchResults, undef, $main::ConfigurationData{'script-url'}, 1, 1, $HTML, %main::FormData);
6924    
6925    
6926    
6927     # Print out mime part separator and mime header for the message footer
6928     if ( $DeliveryMethod eq "attachement" ) {
6929     print("--============_-1234567890==_============\n");
6930     printf("Content-Type: %s; charset=\"us-ascii\"\n\n\n", ($DeliveryFormat eq "text/html") ? "text/html" : "text/plain");
6931     }
6932    
6933    
6934     # Print out the profile result footer
6935     if ( $DeliveryFormat eq "text/html" ) {
6936     print("<BR><HR>\n");
6937     print("Saved search by the <A HREF=\"$main::ConfigurationData{'script-url'}\">MPS Information Server </A><BR>\n");
6938     print("Created by <A HREF=\"http://www.fsconsult.com/\">FS Consulting, Inc.</A><BR>\n");
6939     print("<HR><BR>\n");
6940     print("</BODY>\n");
6941     }
6942     elsif ( ($DeliveryFormat eq "text/plain") || ($DeliveryFormat eq "text/medline-citation") ) {
6943     print("----------------------------------------------------------------------\n");
6944     print("Saved search by the MPS Information Server [URL: $main::ConfigurationData{'script-url'}].\n");
6945     print("Created by FS Consulting, Inc. [URL: http://www.fsconsult.com/].\n");
6946     print("----------------------------------------------------------------------\n");
6947    
6948     }
6949    
6950     # Print out mime part separator for the end of the message
6951     if ( $DeliveryMethod eq "attachement" ) {
6952     print("--============_-1234567890==_============--\n");
6953     }
6954    
6955    
6956     # Restore the saved file handle
6957     select $SavedFileHandle;
6958    
6959     # Close the result file
6960     close(RESULT_FILE);
6961    
6962     }
6963     else {
6964     print("Execution - saved search: '$SavedSearchFilePath' is currently inactive.\n");
6965     }
6966    
6967     # Save the search object
6968     if ( ! &iSaveSearch($SavedSearchFilePath, $SearchName, $SearchDescription, $SearchAndRfDocumentURL, $SearchFrequency, $DeliveryFormat, $DeliveryMethod, $SearchStatus, $CreationTime, $NewLastRunTime) ) {
6969     print("Execution error - failed to save search object: '$SavedSearchFilePath'.\n");
6970     }
6971    
6972     } # foreach ()
6973    
6974     return;
6975    
6976     }
6977    
6978    
6979    
6980    
6981     #--------------------------------------------------------------------------
6982     #
6983     # Function: vLog()
6984     #
6985     # Purpose: This a logging function which logs any passed printf()
6986     # formatted string to STDOUT and the log file if it is defined.
6987     #
6988     # If the log file cannot be opened for appending, nothing will
6989     # be written to it.
6990     #
6991     # Called by:
6992     #
6993     # Parameters: @_
6994     #
6995     # Global Variables: $main::LogFilePath
6996     #
6997     # Returns: void
6998     #
6999     sub vLog {
7000    
7001     # Log to defined log file
7002     if ( defined($main::LogFilePath) && ($main::LogFilePath ne "") && open(LOG_FILE, ">>$main::LogFilePath") ) {
7003     print(LOG_FILE @_);
7004     close(LOG_FILE);
7005     }
7006    
7007     return;
7008    
7009     }
7010    
7011    
7012    
7013    
7014    
7015    
7016     #--------------------------------------------------------------------------
7017     #
7018     # Function: main()
7019     #
7020     # Purpose: main
7021     #
7022     # Called by:
7023     #
7024     # Parameters:
7025     #
7026     # Global Variables:
7027     #
7028     # Returns: void
7029     #
7030    
7031     my ($Status);
7032     my (%Value, $Value);
7033    
7034    
7035    
7036     # Roll over the log file (ignore the status)
7037     # &iRolloverLog($main::LogFilePath, $main::LogFileRollOver);
7038    
7039    
7040     # Verify that we are running the correct perl version, assume upward compatibility
7041     if ( $] < 5.004 ) {
7042     &vLog("Error - this script needs to be run with Perl version 5.004 or better.\n");
7043     &vSendHTMLFooter;
7044     exit (-1);
7045     }
7046    
7047    
7048     # Load up the configuration file
7049     ($Status, %main::ConfigurationData) = &bhReadConfigurationFile($main::ConfigurationFilePath);
7050     if ( ! $Status ) {
7051     &vSendHTMLFooter;
7052     exit (-1);
7053     }
7054    
7055    
7056    
7057     # Set any defaults in the configuration
7058     if ( ! &bSetConfigurationDefaults(\%main::ConfigurationData, \%main::DefaultSettings) ) {
7059     &vSendHTMLFooter;
7060     exit (-1);
7061     }
7062    
7063    
7064     # Check for a minimal configuration
7065     if ( ! &bCheckMinimalConfiguration(\%main::ConfigurationData, \@main::RequiredSettings) ) {
7066     &vSendHTMLFooter;
7067     exit (-1);
7068     }
7069    
7070    
7071     # Check that the configuration paths specified is correct and can be accessed
7072     if ( ! &bCheckConfiguration ) {
7073     &vSendHTMLFooter;
7074     exit (-1);
7075     }
7076    
7077    
7078     # Get the database descriptions
7079     if ( ! &bGetDatabaseDescriptions ) {
7080     &vSendHTMLFooter;
7081     exit (-1);
7082     }
7083    
7084    
7085     # Set up the server
7086     if ( ! &bInitializeServer ) {
7087     &vSendHTMLFooter;
7088     exit (-1);
7089     }
7090    
7091     # fill filed descriptions
7092     &fill_SearchFieldDescriptions_fromDB('ps');
7093    
7094     # Are we running as a CGI-BIN script
7095     if ( $ENV{'GATEWAY_INTERFACE'} ) {
7096    
7097    
7098     # Check the CGI environment
7099     if ( ! &bCheckCGIEnvironment ) {
7100     &vSendHTMLFooter;
7101     exit (-1);
7102     }
7103    
7104    
7105     # Set and verify the environment (dont comment this out).
7106     if ( ! &bSetupCGIEnvironment ) {
7107     &vSendHTMLFooter;
7108     exit (-1);
7109     }
7110    
7111    
7112 dpavlin 1.12 if ( defined($main::FormData{'GetSearch'}) ) {
7113 dpavlin 1.1 $ENV{'PATH_INFO'} = "/GetSearch";
7114 dpavlin 1.12 delete($main::FormData{'GetSearch'});
7115     delete($main::FormData{'GetSearch'});
7116 dpavlin 1.1 }
7117    
7118 dpavlin 1.12 if ( defined($main::FormData{'ListSearchHistory'}) ) {
7119 dpavlin 1.1 $ENV{'PATH_INFO'} = "/ListSearchHistory";
7120 dpavlin 1.12 delete($main::FormData{'ListSearchHistory'});
7121     delete($main::FormData{'ListSearchHistory'});
7122 dpavlin 1.1 }
7123    
7124 dpavlin 1.12 if ( defined($main::FormData{'ListSavedSearch'}) ) {
7125 dpavlin 1.1 $ENV{'PATH_INFO'} = "/ListSavedSearch";
7126 dpavlin 1.12 delete($main::FormData{'ListSavedSearch'});
7127     delete($main::FormData{'ListSavedSearch'});
7128 dpavlin 1.1 }
7129    
7130 dpavlin 1.12 if ( defined($main::FormData{'ListFolder'}) ) {
7131 dpavlin 1.1 $ENV{'PATH_INFO'} = "/ListFolder";
7132 dpavlin 1.12 delete($main::FormData{'ListFolder'});
7133     delete($main::FormData{'ListFolder'});
7134 dpavlin 1.1 }
7135    
7136 dpavlin 1.12 if ( defined($main::FormData{'GetUserSettings'}) ) {
7137 dpavlin 1.1 $ENV{'PATH_INFO'} = "/GetUserSettings";
7138 dpavlin 1.12 delete($main::FormData{'GetUserSettings'});
7139     delete($main::FormData{'GetUserSettings'});
7140 dpavlin 1.1 }
7141    
7142    
7143    
7144     # foreach $Value ( keys (%main::FormData) ) {
7145     # $Status = defined($main::FormData{$Value}) ? $main::FormData{$Value} : "(undefined)";
7146     # &vLog("[\$main::FormData{'$Value'} = '$Status']\n");
7147     # }
7148    
7149     # Check for 'Action', set the PATH_INFO from it if it is set
7150     if ( defined($main::FormData{'Action'}) ) {
7151    
7152     if ( ($Value = index($main::FormData{'Action'}, "&")) > 0 ) {
7153     %Value = &hParseURLIntoHashTable(&lDecodeURLData(substr($main::FormData{'Action'}, $Value)));
7154     $main::FormData{'Action'} = substr($main::FormData{'Action'}, 0, $Value);
7155     foreach $Value ( keys(%Value) ) {
7156     $main::FormData{$Value} = $Value{$Value};
7157     }
7158     }
7159    
7160     $ENV{'PATH_INFO'} = "/" . $main::FormData{'Action'};
7161     delete($main::FormData{'Action'});
7162     }
7163    
7164    
7165     # Default to search if PATH_INFO is not defined
7166     if ( !defined($ENV{'PATH_INFO'}) || ($ENV{'PATH_INFO'} eq "") ) {
7167     $ENV{'PATH_INFO'} = "/GetSearch";
7168     }
7169    
7170    
7171     # Check what was requested and take action appropriately
7172     if ( ($ENV{'PATH_INFO'} eq "/GetSearch") || ($ENV{'PATH_INFO'} eq "/GetSimpleSearch") || ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ) {
7173     &vGetSearch;
7174     }
7175     elsif ( $ENV{'PATH_INFO'} eq "/GetSearchResults" ) {
7176     &vGetSearchResults;
7177     }
7178     elsif ( $ENV{'PATH_INFO'} eq "/GetDatabaseInfo" ) {
7179     &vGetDatabaseInfo;
7180     }
7181     elsif ( $ENV{'PATH_INFO'} eq "/GetDocument" ) {
7182     &vGetDocument;
7183     }
7184     elsif ( $ENV{'PATH_INFO'} eq "/GetSimilarDocument" ) {
7185     &vGetDocument;
7186     }
7187     elsif ( $ENV{'PATH_INFO'} eq "/GetUserSettings" ) {
7188     &vGetUserSettings;
7189     }
7190     elsif ( $ENV{'PATH_INFO'} eq "/SetUserSettings" ) {
7191     &vSetUserSettings;
7192     }
7193     elsif ( $ENV{'PATH_INFO'} eq "/ListSearchHistory" ) {
7194     &vListSearchHistory;
7195     }
7196     elsif ( $ENV{'PATH_INFO'} eq "/GetSearchHistory" ) {
7197     &vGetSearchHistory;
7198     }
7199     elsif ( $ENV{'PATH_INFO'} eq "/GetSaveSearch" ) {
7200     &vGetSaveSearch;
7201     }
7202     elsif ( $ENV{'PATH_INFO'} eq "/SetSaveSearch" ) {
7203     &vSetSaveSearch;
7204     }
7205     elsif ( $ENV{'PATH_INFO'} eq "/ListSavedSearch" ) {
7206     &vListSavedSearch;
7207     }
7208     elsif ( $ENV{'PATH_INFO'} eq "/GetSavedSearch" ) {
7209     &vGetSavedSearch;
7210     }
7211     elsif ( $ENV{'PATH_INFO'} eq "/DeleteSavedSearch" ) {
7212     &vProcessSavedSearch;
7213     }
7214     elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
7215     &vProcessSavedSearch;
7216     }
7217     elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
7218     &vProcessSavedSearch;
7219     }
7220     elsif ( $ENV{'PATH_INFO'} eq "/GetSaveFolder" ) {
7221     &vGetSaveFolder;
7222     }
7223     elsif ( $ENV{'PATH_INFO'} eq "/SetSaveFolder" ) {
7224     &vSetSaveFolder;
7225     }
7226     elsif ( $ENV{'PATH_INFO'} eq "/ListFolder" ) {
7227     &vListFolder;
7228     }
7229     elsif ( $ENV{'PATH_INFO'} eq "/SetMergeFolder" ) {
7230     &vMergeFolder;
7231     }
7232     elsif ( $ENV{'PATH_INFO'} eq "/GetMergeFolder" ) {
7233     &vMergeFolder;
7234     }
7235     elsif ( $ENV{'PATH_INFO'} eq "/DeleteFolder" ) {
7236     &vProcessFolder;
7237     }
7238     elsif ( $ENV{'PATH_INFO'} eq "/GetFolder" ) {
7239     &vGetFolder;
7240     }
7241     elsif ( $ENV{'PATH_INFO'} eq "/DeleteDocument" ) {
7242     &vProcessDocument;
7243     }
7244     else {
7245     $ENV{'PATH_INFO'} = "/GetSearch";
7246     &vGetSearch;
7247     }
7248    
7249     }
7250     else {
7251    
7252     my ($RunSearches, $Param, $Frequency, $Mday, $Wday);
7253    
7254    
7255     # We are running as a stand alone script
7256    
7257    
7258     #
7259     # Initialize the variables
7260     #
7261    
7262     # Run Searches?
7263     # 0 - dont run searches
7264     # 1 - run searches
7265     $RunSearches = 1;
7266    
7267    
7268     # Init the frequency
7269     $Frequency = "";
7270    
7271     # Check for command parameters
7272     foreach $Param ( @ARGV ) {
7273    
7274     if ( $Param =~ /^-nos/i ) {
7275     # Dont run searches
7276     $RunSearches = 0;
7277     }
7278     elsif ( $Param =~ /^-s/i ) {
7279     # Run searches
7280     $RunSearches = 1;
7281     }
7282     elsif ( $Param =~ /^-d/i ) {
7283     # Want to run the daily
7284     $Frequency .= "|Daily|";
7285     }
7286     elsif ( $Param =~ /^-w/i ) {
7287     # Want to run the weekly
7288     $Frequency .= "|Weekly|";
7289     }
7290     elsif ( $Param =~ /^-m/i ) {
7291     # Want to run the monthly
7292     $Frequency .= "|Monthly|";
7293     }
7294     elsif ( $Param =~ /^-h/i ) {
7295     # help
7296     print("Usage: Search.cgi [-nosearch|-search] [-daily][-weekly][-monthly][-help]\n");
7297     print("\n");
7298     print(" [-nosearch|-search] whether to run or not run searches (default = -search).\n");
7299     print(" [-daily] run daily crawls/searches (overrides default).\n");
7300     print(" [-weekly] run weekly crawls/searches (overrides default).\n");
7301     print(" [-monthly] run monthly crawls/searches (overrides default).\n");
7302     print(" [-help] print the usage and exit.\n");
7303     exit (0);
7304     }
7305     else {
7306     # Invalid param
7307     print("\tError - invalid parameter: '$Param', run 'Search.cgi -help' to get parameter information.\n");
7308     exit (-2);
7309     }
7310     }
7311    
7312    
7313    
7314     # Did we set a frequency usign a command line parameter?
7315     if ( $Frequency eq "" ) {
7316    
7317     # We did not, so we set it based on the following rules
7318     #
7319     # monday-sunday run the daily
7320     # sunday run the weekly
7321     # 1st of the month run the monthly
7322     #
7323    
7324     # Create an ANSI format date/time field
7325     (undef, undef, undef, $Mday, undef, undef, $Wday, undef, undef) = localtime();
7326    
7327     # Always do the daily
7328     $Frequency = "|Daily|";
7329    
7330     # Check for sunday, append the weekly
7331     if ( $Wday == 0 ) {
7332     $Frequency .= "|Weekly|";
7333     }
7334    
7335     # Check for the 1st of the month, append the monthly
7336     if ( $Mday == 1 ) {
7337     $Frequency .= "|Monthly|";
7338     }
7339     }
7340    
7341    
7342     # Log stuff
7343     print("Execution - Frequency: $Frequency\n");
7344    
7345    
7346     # Run the searches
7347     if ( $RunSearches == 1 ) {
7348     &vRunSavedSearches($Frequency);
7349     }
7350     }
7351    
7352    
7353     # Shutdown the server
7354     &bShutdownServer;
7355    
7356    
7357     exit (0);
7358    
7359    
7360    
7361     #--------------------------------------------------------------------------
7362    
7363     # fill SearchFieldDescriptions from one database
7364    
7365     # 2002-06-08 Dobrica Pavlinusic <dpavlin@rot13.org>
7366    
7367     sub fill_SearchFieldDescriptions_fromDB {
7368    
7369     my ($Database) = @_;
7370    
7371     # Get the database field information
7372     my ($Status, $Text) = MPS::GetDatabaseFieldInfo($main::MPSSession, $Database);
7373    
7374     if ( $Status ) {
7375     foreach my $FieldInformation ( split(/\n/, $Text) ) {
7376     my ($FieldName, $FieldDescription, undef) = split(/\t/, $FieldInformation, 3);
7377     $main::SearchFieldDescriptions{$FieldName} = $FieldDescription;
7378     }
7379     }
7380 dpavlin 1.7 }
7381    
7382     #--------------------------------------------------------------------------
7383     # show list of all databases
7384     #
7385     # usage: ShowDatabaseCheckBoxes(@SelectedDatabases)
7386    
7387     sub ShowDatabaseCheckBoxes {
7388     # Parse out the database names and put them into a
7389     # hash table, they should be separated with a '\0'
7390     my %Value;
7391    
7392     foreach my $ItemEntry ( @_ ) {
7393     $Value{$ItemEntry} = $ItemEntry;
7394     }
7395    
7396     print("<TABLE BORDER=0 CELLPADDING=0 CELLSPACING=0>\n");
7397 dpavlin 1.15 print "<tr><td colspan=3 align=\"center\">
7398     <font size=-1>Oznaèi
7399     <a href=\"javascript:SetChecked(1)\">sve</a>,
7400     <a href=\"javascript:SetChecked(0)\">niti jednu</a>.
7401     </font>
7402     </td></tr>";
7403 dpavlin 1.7
7404     my @html_database;
7405    
7406     foreach my $key ( sort keys %main::DatabaseSort ) {
7407     my $DatabaseName = $main::DatabaseSort{$key};
7408     my $Value = ((defined($Value{$DatabaseName})) || (scalar(keys(%main::DatabaseDescriptions)) == 1) || !defined($main::RemoteUser) ) ? "CHECKED" : "";
7409     my $ItemEntry = &lEncodeURLData($DatabaseName);
7410     if ($main::DatabaseDescriptions{$DatabaseName}) {
7411     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";
7412     } else {
7413     push @html_database,"<td align=left valign=top>$main::DatabaseDescriptions{$DatabaseName}</td>\n";
7414     }
7415     }
7416    
7417    
7418     if ($main::ConfigurationData{'output-colums'}) {
7419     # create database names in columns
7420    
7421     my $cols = $main::ConfigurationData{'show-nr-colums'};
7422     my $next = int($#html_database/$cols) ;
7423    
7424     for(my $i=0; $i <= $next ; $i++) {
7425     print("<tr>");
7426     for(my $j=0; $j <= $cols; $j++) {
7427     print($html_database[$i+$next*$j+$j] || '');
7428     }
7429     print("</tr>");
7430     }
7431    
7432     } else {
7433     for(my $i=0; $i <= $#html_database ; $i=$i+1) {
7434     print("<tr>",$html_database[$i],"</tr>");
7435     }
7436     }
7437    
7438     print("</TABLE>\n");
7439 dpavlin 1.1 }

  ViewVC Help
Powered by ViewVC 1.1.26