/[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

Contents of /search/Search.cgi

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.21 - (show 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 #!/usr/bin/perl -w
2
3 #*****************************************************************************
4 # 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 #*****************************************************************************
14
15 #print "Content-type: text/plain\n\n";
16
17 #use Data::Dumper;
18
19 #--------------------------------------------------------------------------
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 # read configuration fields
187 require "config.pm";
188
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
380 # 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 print '<link rel="STYLESHEET" type="text/css" href="'.$main::ConfigurationData{'image-base-path'}.'/stil.css">';
396 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 # 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
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 my $DISABLED;
507
508 $DISABLED = ( %MenuBar && defined($MenuBar{'GetSearch'}) ) ? "DISABLED" : "";
509 print("<INPUT NAME=\"GetSearch\" TYPE=SUBMIT VALUE=\"Pretra¾ivanje\" $DISABLED class=\"navigacija${DISABLED}\">");
510
511 if ( defined($main::RemoteUser) ) {
512 $DISABLED = ( %MenuBar && defined($MenuBar{'ListSearchHistory'}) ) ? "DISABLED" : "";
513 print"<INPUT NAME=\"ListSearchHistory\" TYPE=SUBMIT VALUE=\"Prija¹nja pretra¾ivanja\" $DISABLED class=\"navigacija${DISABLED}\">";
514
515 $DISABLED = ( %MenuBar && defined($MenuBar{'ListSavedSearch'}) ) ? "DISABLED" : "";
516 print"<INPUT NAME=\"ListSavedSearch\" TYPE=SUBMIT VALUE=\"Saèuvani upiti\" $DISABLED class=\"navigacija${DISABLED}\">";
517
518 $DISABLED = ( %MenuBar && defined($MenuBar{'ListFolder'}) ) ? "DISABLED" : "";
519 print"<INPUT NAME=\"ListFolder\" TYPE=SUBMIT VALUE=\"Korisnièki folderi\" $DISABLED class=\"navigacija${DISABLED}\">";
520
521 $DISABLED = ( %MenuBar && defined($MenuBar{'GetUserSettings'}) ) ? "DISABLED" : "";
522 print"<INPUT NAME=\"GetUserSettings\" TYPE=SUBMIT VALUE=\"Korisnièke postavke\" $DISABLED class=\"navigacija${DISABLED}\">";
523 }
524
525
526 print("</FORM>\n");
527
528 # Close off the menu bar cell
529 print("</TD></TR>\n");
530
531 print("</TABLE>\n");
532
533
534 return;
535 }
536
537
538
539
540
541
542 #--------------------------------------------------------------------------
543 #
544 # Function: vHandleError()
545 #
546 # Purpose: This function handles any errors messages that need to be
547 # reported when an error occurs
548 #
549 # This error handler also displays the header if needed
550 #
551 # Called by:
552 #
553 # Parameters: $Header header
554 # $Message message
555 #
556 # Global Variables:
557 #
558 # Returns: void
559 #
560 sub vHandleError {
561
562 my ($Header, $Message) = @_;
563
564 my ($Package, $FileName, $Line);
565
566
567 # Make sure we send the header
568 &vSendHTMLHeader("Error", undef);
569
570
571 printf("<H3> %s: </H3>\n", defined($Header) ? $Header : "No header supplied");
572 printf("<H3><CENTER> %s. </CENTER></H3>\n", defined($Message) ? $Message : "No error message supplied");
573 print("<P>\n");
574 if ( defined($main::ConfigurationData{'site-admin-url'}) ) {
575 print("<CENTER> Please <A HREF=\"$main::ConfigurationData{'site-admin-url'}\"> contact the administrator </A> of this system to correct the problem. </CENTER>\n");
576 }
577 else {
578 print("<CENTER> Please contact the administrator of this system to correct the problem. </CENTER>\n");
579 }
580 print("<P><HR WIDTH=50%><P>\n");
581
582
583 # Send package information
584 # ($Package, $FileName, $Line) = caller;
585 # print("Package = [$Package], FileName = [$FileName], Line = [$Line] <BR>\n");
586
587 return;
588 }
589
590
591
592
593
594 #--------------------------------------------------------------------------
595 #
596 # Function: bCheckConfiguration()
597 #
598 # Purpose: This function checks that the configuration settings
599 # specified are correct and that any directory paths and
600 # files specified are there and can be accessed.
601 #
602 # We check both required settings and optional setting if
603 # they have been set.
604 #
605 # An error here should be considered fatal.
606 #
607 # Called by:
608 #
609 # Parameters: void
610 #
611 # Global Variables: %main::ConfigurationData
612 #
613 # Returns: Boolean status
614 #
615 sub bCheckConfiguration {
616
617 my ($Value, $Status);
618
619
620 # Init the status
621 $Status = 1;
622
623
624 # Check 'user-accounts-directory' (optional)
625 if ( defined($main::ConfigurationData{'user-accounts-directory'}) ) {
626
627 $main::ConfigurationData{'user-accounts-directory'} = &sCleanSetting('user-accounts-directory', $main::ConfigurationData{'user-accounts-directory'}, $main::RootDirectoryPath);
628 $Value = $main::ConfigurationData{'user-accounts-directory'};
629
630 # Check that the directory exists
631 if ( ! (-d $Value) ) {
632 &vLog("Error - configuration setting: 'user-accounts-directory', directory: '$Value' does not exist.\n");
633 $Status = 0;
634 }
635 else {
636
637 # The directory exists, now check that it can be accessed
638 if ( ! ((-r $Value) && (-w $Value) && (-x $Value)) ) {
639 &vLog("Error - configuration setting: 'user-accounts-directory', directory: '$Value' cannot be accessed.\n");
640 $Status = 0;
641 }
642 }
643 }
644
645
646
647 # Check 'database-description-file' (optional)
648 if ( defined($main::ConfigurationData{'database-description-file'}) ) {
649
650 $main::ConfigurationData{'database-description-file'} = &sCleanSetting('database-description-file', $main::ConfigurationData{'database-description-file'}, $main::RootDirectoryPath);
651 $Value = $main::ConfigurationData{'database-description-file'};
652
653 # Check that the file exists
654 if ( ! ((-f $Value) && (-r $Value)) ) {
655 &vLog("Error - configuration setting: 'database-description-file', file: '$Value' does not exist.\n");
656 $Status = 0;
657 }
658 }
659
660
661
662 # Check 'allow-summary-displays' (optional)
663 if ( defined($main::ConfigurationData{'allow-summary-displays'}) ) {
664
665 # Clean the setting and convert to lower case
666 $main::ConfigurationData{'allow-summary-displays'} = &sCleanSetting('allow-summary-displays', $main::ConfigurationData{'allow-summary-displays'});
667 $main::ConfigurationData{'allow-summary-displays'} = lc($main::ConfigurationData{'allow-summary-displays'});
668
669 # Check that the setting is valid
670 if ( ($main::ConfigurationData{'allow-summary-displays'} ne "yes") && ($main::ConfigurationData{'allow-summary-displays'} ne "no")) {
671 &vLog("Warning - configuration setting: 'allow-summary-displays', setting not recognized: $main::ConfigurationData{'allow-summary-displays'}.\n");
672 }
673 }
674
675
676
677 # Check 'allow-similiar-search' (optional)
678 if ( defined($main::ConfigurationData{'allow-similiar-search'}) ) {
679
680 # Clean the setting and convert to lower case
681 $main::ConfigurationData{'allow-similiar-search'} = &sCleanSetting('allow-similiar-search', $main::ConfigurationData{'allow-similiar-search'});
682 $main::ConfigurationData{'allow-similiar-search'} = lc($main::ConfigurationData{'allow-similiar-search'});
683
684 # Check that the setting is valid
685 if ( ($main::ConfigurationData{'allow-similiar-search'} ne "yes") && ($main::ConfigurationData{'allow-similiar-search'} ne "no")) {
686 &vLog("Warning - configuration setting: 'allow-similiar-search', setting not recognized: $main::ConfigurationData{'allow-similiar-search'}.\n");
687 }
688 }
689
690
691
692 # Check 'allow-regular-searches' (optional)
693 if ( defined($main::ConfigurationData{'allow-regular-searches'}) ) {
694
695 # Clean the setting and convert to lower case
696 $main::ConfigurationData{'allow-regular-searches'} = &sCleanSetting('allow-regular-searches', $main::ConfigurationData{'allow-regular-searches'});
697 $main::ConfigurationData{'allow-regular-searches'} = lc($main::ConfigurationData{'allow-regular-searches'});
698
699 # Check that the setting is valid
700 if ( ($main::ConfigurationData{'allow-regular-searches'} ne "yes") && ($main::ConfigurationData{'allow-regular-searches'} ne "no")) {
701 &vLog("Warning - configuration setting: 'allow-regular-searches', setting not recognized: $main::ConfigurationData{'allow-regular-searches'}.\n");
702 }
703 }
704
705
706
707 # Check 'deliver-empty-results-from-regular-search' (optional)
708 if ( defined($main::ConfigurationData{'deliver-empty-results-from-regular-search'}) ) {
709
710 # Clean the setting and convert to lower case
711 $main::ConfigurationData{'deliver-empty-results-from-regular-search'} = &sCleanSetting('deliver-empty-results-from-regular-search', $main::ConfigurationData{'deliver-empty-results-from-regular-search'});
712 $main::ConfigurationData{'deliver-empty-results-from-regular-search'} = lc($main::ConfigurationData{'deliver-empty-results-from-regular-search'});
713
714 # Check that the setting is valid
715 if ( ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} ne "yes") && ($main::ConfigurationData{'deliver-empty-results-from-regular-search'} ne "no")) {
716 &vLog("Warning - configuration setting: 'deliver-empty-results-from-regular-search', setting not recognized: $main::ConfigurationData{'deliver-empty-results-from-regular-search'}.\n");
717 }
718 }
719
720
721
722 # Check 'allow-relevance-feedback-searches' (optional)
723 if ( defined($main::ConfigurationData{'allow-relevance-feedback-searches'}) ) {
724
725 # Clean the setting and convert to lower case
726 $main::ConfigurationData{'allow-relevance-feedback-searches'} = &sCleanSetting('allow-relevance-feedback-searches', $main::ConfigurationData{'allow-relevance-feedback-searches'});
727 $main::ConfigurationData{'allow-relevance-feedback-searches'} = lc($main::ConfigurationData{'allow-relevance-feedback-searches'});
728
729 # Check that the setting is valid
730 if ( ($main::ConfigurationData{'allow-relevance-feedback-searches'} ne "yes") && ($main::ConfigurationData{'allow-relevance-feedback-searches'} ne "no")) {
731 &vLog("Warning - configuration setting: 'allow-relevance-feedback-searches', setting not recognized: $main::ConfigurationData{'allow-relevance-feedback-searches'}.\n");
732 }
733 }
734
735
736
737 # Check 'html-directory' (required)
738 $main::ConfigurationData{'html-directory'} = &sCleanSetting('html-directory', $main::ConfigurationData{'html-directory'}, $main::RootDirectoryPath);
739 $Value = $main::ConfigurationData{'html-directory'};
740
741 # Check that the directory exists
742 if ( ! (-d $Value) ) {
743 &vLog("Error - configuration setting: 'html-directory', directory: '$Value' does not exist.\n");
744 $Status = 0;
745 }
746 else {
747
748 # The directory exists, now check that it can be accessed
749 if ( ! ((-r $Value) && (-x $Value)) ) {
750 &vLog("Error - configuration setting: 'html-directory', directory: '$Value' cannot be accessed.\n");
751 $Status = 0;
752 }
753 }
754
755
756
757 # Check 'image-base-path' (required)
758 $main::ConfigurationData{'image-base-path'} = &sCleanSetting('image-base-path', $main::ConfigurationData{'image-base-path'});
759 $Value = $main::ConfigurationData{'html-directory'} . $main::ConfigurationData{'image-base-path'};
760
761 # Check that the directory exists
762 if ( ! (-d $Value) ) {
763 &vLog("Error - configuration setting: 'image-base-path', directory: '$Value' does not exist.\n");
764 $Status = 0;
765 }
766 else {
767
768 my ($ImageName);
769
770 # The directory exists, now check that it can be accessed
771 if ( ! ((-r $Value) && (-x $Value)) ) {
772 &vLog("Error - configuration setting: 'image-base-path', directory: '$Value' cannot be accessed.\n");
773 $Status = 0;
774 }
775
776
777 # Check the general icons
778 foreach $ImageName ( values(%main::ImageNames) ) {
779
780 $Value = $main::ConfigurationData{'html-directory'} . $main::ConfigurationData{'image-base-path'} . "/" . $ImageName;
781
782 # Check that the file exists
783 if ( ! ((-f $Value) && (-r $Value)) ) {
784 &vLog("Error - configuration setting: 'image-base-path', file: '$Value' does not exist.\n");
785 $Status = 0;
786 }
787 }
788 }
789
790
791
792 # Check 'html-header-snippet-file' (optional)
793 if ( defined($main::ConfigurationData{'html-header-snippet-file'}) ) {
794
795 $main::ConfigurationData{'html-header-snippet-file'} = &sCleanSetting('html-header-snippet-file', $main::ConfigurationData{'html-header-snippet-file'}, $main::RootDirectoryPath);
796 $Value = $main::ConfigurationData{'html-header-snippet-file'};
797
798 # Check that the file exists
799 if ( ! ((-f $Value) && (-r $Value)) ) {
800 &vLog("Error - configuration setting: 'html-header-snippet-file', file: '$Value' does not exist.\n");
801 $Status = 0;
802 }
803 }
804
805
806
807 # Check 'html-footer-snippet-file' (optional)
808 if ( defined($main::ConfigurationData{'html-footer-snippet-file'}) ) {
809
810 $main::ConfigurationData{'html-footer-snippet-file'} = &sCleanSetting('html-footer-snippet-file', $main::ConfigurationData{'html-footer-snippet-file'}, $main::RootDirectoryPath);
811 $Value = $main::ConfigurationData{'html-footer-snippet-file'};
812
813 # Check that the file exists
814 if ( ! ((-f $Value) && (-r $Value)) ) {
815 &vLog("Error - configuration setting: 'html-footer-snippet-file', file: '$Value' does not exist.\n");
816 $Status = 0;
817 }
818 }
819
820
821
822 # Check 'logs-directory' (required)
823 $main::ConfigurationData{'logs-directory'} = &sCleanSetting('logs-directory', $main::ConfigurationData{'logs-directory'}, $main::RootDirectoryPath);
824 $Value = $main::ConfigurationData{'logs-directory'};
825
826 # Check that the directory exists
827 if ( ! (-d $Value) ) {
828 &vLog("Error - configuration setting: 'logs-directory', directory: '$Value' does not exist.\n");
829 $Status = 0;
830 }
831 else {
832
833 # The directory exists, now check that it can be accessed
834 if ( ! ((-r $Value) && (-w $Value) && (-x $Value)) ) {
835 &vLog("Error - configuration setting: 'logs-directory', directory: '$Value' cannot be accessed.\n");
836 $Status = 0;
837 }
838 }
839
840
841
842 # Check 'database-directory' (required)
843 $main::ConfigurationData{'database-directory'} = &sCleanSetting('database-directory', $main::ConfigurationData{'database-directory'}, $main::RootDirectoryPath);
844 $Value = $main::ConfigurationData{'database-directory'};
845
846 # Check that the directory exists
847 if ( ! (-d $Value) ) {
848 &vLog("Error - configuration setting: 'database-directory', directory: '$Value' does not exist.\n");
849 $Status = 0;
850 }
851 else {
852
853 # The directory exists, now check that it can be accessed
854 if ( ! ((-r $Value) && (-x $Value)) ) {
855 &vLog("Error - configuration setting: 'database-directory, directory: '$Value' cannot be accessed.\n");
856 $Status = 0;
857 }
858 }
859
860
861
862 # Check 'configuration-directory' (required)
863 $main::ConfigurationData{'configuration-directory'} = &sCleanSetting('configuration-directory', $main::ConfigurationData{'configuration-directory'}, $main::RootDirectoryPath);
864 $Value = $main::ConfigurationData{'configuration-directory'};
865
866 # Check that the directory exists
867 if ( ! (-d $Value) ) {
868 &vLog("Error - configuration setting: 'configuration-directory', directory: '$Value' does not exist.\n");
869 $Status = 0;
870 }
871 else {
872
873 # The directory exists, now check that it can be accessed
874 if ( ! ((-r $Value) && (-x $Value)) ) {
875 &vLog("Error - configuration setting: 'configuration-directory, directory: '$Value' cannot be accessed.\n");
876 $Status = 0;
877 }
878 }
879
880
881
882 # Check 'server-log' (optional with default)
883 $main::ConfigurationData{'server-log'} = &sCleanSetting('server-log', $main::ConfigurationData{'server-log'});
884 $Value = $main::ConfigurationData{'logs-directory'} . "/" . $main::ConfigurationData{'server-log'};
885
886 # Check that we can write to the log file if it exists
887 if ( -f $Value ) {
888
889 # The file exists, now check that it can be accessed
890 if ( ! -w $Value ) {
891 &vLog("Error - configuration setting: 'server-log', directory: '$Value' cannot be accessed.\n");
892 $Status = 0;
893 }
894 }
895
896
897
898 # Check 'mailer-application' (optional with default)
899 if ( defined($main::ConfigurationData{'allow-regular-searches'}) && ($main::ConfigurationData{'allow-regular-searches'} eq "yes") ) {
900
901 $main::ConfigurationData{'mailer-application'} = &sCleanSetting('mailer-application', $main::ConfigurationData{'mailer-application'}, $main::RootDirectoryPath);
902 $Value = $main::ConfigurationData{'mailer-application'};
903
904 # Check that the application can be executed
905 if ( ! (-x $Value) ) {
906 &vLog("Error - configuration setting: 'mailer-application', application: '$Value' cannot be executed.\n");
907 $Status = 0;
908 }
909 }
910
911
912 return ($Status);
913
914 }
915
916
917
918
919
920 #--------------------------------------------------------------------------
921 #
922 # Function: bGetDatabaseDescriptions()
923 #
924 # Purpose: This function reads the database description file and places it in the
925 # hash table global, note that the hash table is not cleared before
926 # we start to add kay/value pairs to it.
927 #
928 # Any line which starts with a '#' or is empty will be skipped.
929 #
930 # An error will be generated if we try to redefine a value for a
931 # key that has already been defined.
932 #
933 # An error here should be considered fatal.
934 #
935 # Called by:
936 #
937 # Parameters: void
938 #
939 # Global Variables: %main::ConfigurationData, %main::DatabaseDescriptions
940 #
941 # Returns: Boolean status
942 #
943 sub bGetDatabaseDescriptions {
944
945 my ($Status, $Key, $KeyValue, $KeyBase, $KeyLeaf, $Database);
946
947
948 # Init the status
949 $Status = 1;
950
951
952 # Only check the database description file if it is available
953 if ( defined($main::ConfigurationData{'database-description-file'}) ) {
954
955 # Open the database description file
956 if ( ! open(FILE, "$main::ConfigurationData{'database-description-file'}") ) {
957 &vLog("Error - could not open database description file: '$main::ConfigurationData{'database-description-file'}'.\n");
958 return (0);
959 }
960
961 # Read in each line in the file, ignore empty
962 # lines and lines which start with a '#'
963 while (<FILE>) {
964
965 chop $_;
966
967 # Check to see if this line is empty or is a comment, and skip them
968 if ( (length($_) == 0) || ($_ =~ /^#/) ) {
969 next;
970 }
971
972 # Split the configuration string into a set of key/value pairs
973 ($Key, $KeyValue) = split(/=/, $_);
974
975 # Only add values which are defined
976 if ( defined($KeyValue) && ($KeyValue ne "") ) {
977
978 # Split the key into a key and a subkey
979 ($KeyBase, $KeyLeaf) = split(/:/, $Key, 2);
980
981 if ( $KeyBase eq $main::DatabaseName ) {
982
983 # Add the key/value pairs to the hash table
984 if ( defined($main::DatabaseDescriptions{$KeyLeaf}) ) {
985 # Fail if the value for this key is already defined
986 &vLog("Error - value for: '$KeyLeaf', is already defined as: '$main::DatabaseDescriptions{$KeyLeaf}', tried to redefine it to: '$KeyValue'.\n");
987 $Status = 0;
988 }
989 else {
990 # Add the value for this key
991 if ($KeyValue =~ s/(##sort[^#]+##)//) {
992 $main::DatabaseSort{$1} = $KeyLeaf;
993 } else {
994 $main::DatabaseSort{$KeyValue} = $KeyLeaf;
995 }
996 $main::DatabaseDescriptions{$KeyLeaf} = $KeyValue;
997 }
998 }
999 elsif ( $KeyBase eq $main::DatabaseFiltersPackage ) {
1000
1001 # Add the key/value pairs to the hash table
1002 if ( defined($main::DatabaseFilters{$Key}) ) {
1003 # Fail if the value for this key is already defined
1004 &vLog("Error - value for: '$Key', is already defined as: '$main::DatabaseFilters{$Key}', tried to redefine it to: '$KeyValue'.\n");
1005 $Status = 0;
1006 }
1007 else {
1008
1009 # Check that this filters package exists
1010 if ( ! -x $KeyValue ) {
1011 # Fail we cant find it
1012 &vLog("Error - filter: '$KeyValue' for: '$Key' could not be found.\n");
1013 $Status = 0;
1014 }
1015
1016 # Add the value for this key
1017 $main::DatabaseFilters{$Key} = $KeyValue;
1018 }
1019 }
1020 else {
1021
1022 ($Database) = split(/:/, $KeyLeaf);
1023
1024 # Add the key/value pairs to the hash table
1025 if ( ! defined($main::DatabaseFilters{"$main::DatabaseFiltersPackage:$Database"}) ) {
1026 # Fail if we dont have the package for this function
1027 &vLog("Error - package file for function: '$KeyValue', defined for: '$Key', cound not be found.\n");
1028 $Status = 0;
1029 }
1030 elsif ( defined($main::DatabaseFilters{$Key}) ) {
1031 # Fail if the value for this key is already defined
1032 &vLog("Error - value for: '$Key', is already defined as: '$main::DatabaseFilters{$Key}', tried to redefine it to: '$KeyValue'.\n");
1033 $Status = 0;
1034 }
1035 else {
1036
1037 # Add the value for this key
1038 $main::DatabaseFilters{$Key} = $KeyValue;
1039 }
1040 }
1041 }
1042 }
1043 close(FILE);
1044 }
1045
1046 # fill defaults for rest
1047 $main::DatabaseFilters{$Key} = $main::DatabaseFilters{default} if (! defined($main::DatabaseFilters{$Key}));
1048
1049 return ($Status);
1050
1051 }
1052
1053
1054
1055
1056
1057 #--------------------------------------------------------------------------
1058 #
1059 # Function: bInitializeServer()
1060 #
1061 # Purpose: This function sets up the server
1062 #
1063 # An error here should be considered fatal.
1064 #
1065 # Called by:
1066 #
1067 # Parameters: void
1068 #
1069 # Global Variables: %main::ConfigurationData
1070 #
1071 # Returns: Boolean status
1072 #
1073 sub bInitializeServer {
1074
1075 my ($Status, $Text);
1076 my ($ErrorNumber, $ErrorMessage);
1077
1078
1079 # Initialize the server
1080 ($Status, $Text) = MPS::InitializeServer($main::ConfigurationData{'database-directory'}, $main::ConfigurationData{'configuration-directory'}, $main::ConfigurationData{'logs-directory'} . "/". $main::ConfigurationData{'server-log'}, MPS_LOG_MEDIUM);
1081
1082 # Check the return code
1083 if ( ! $Status ) {
1084 ($ErrorNumber, $ErrorMessage) = split(/\t/, $Text, 2);
1085 &vHandleError("Database Search", "Sorry, failed to initialize the server");
1086 print("The following error message was reported: <BR>\n");
1087 print("Error Message: $ErrorMessage <BR>\n");
1088 print("Error Number: $ErrorNumber <BR>\n");
1089 }
1090
1091 $main::MPSSession = $Text;
1092
1093 return ($Status);
1094 }
1095
1096
1097
1098
1099
1100 #--------------------------------------------------------------------------
1101 #
1102 # Function: bShutdownServer()
1103 #
1104 # Purpose: This function shuts down the server
1105 #
1106 # An error here should be considered fatal.
1107 #
1108 # Called by:
1109 #
1110 # Parameters: void
1111 #
1112 # Global Variables: %main::ConfigurationData
1113 #
1114 # Returns: Boolean status
1115 #
1116 sub bShutdownServer {
1117
1118
1119 # Shutdown the server
1120 MPS::ShutdownServer($main::MPSSession);
1121
1122 return (1);
1123
1124 }
1125
1126
1127
1128
1129
1130 #--------------------------------------------------------------------------
1131 #
1132 # Function: bCheckCGIEnvironment()
1133 #
1134 # Purpose: This function checks that all the CGI environment variables we
1135 # need are available. It will exit if any of the variables are
1136 # not found, but it will first list all the variables that are
1137 # not available.
1138 #
1139 # An error here should be considered fatal.
1140 #
1141 # Called by:
1142 #
1143 # Parameters: void
1144 #
1145 # Global Variables: $ENV{}
1146 #
1147 # Returns: Boolean status
1148 #
1149 sub bCheckCGIEnvironment {
1150
1151 my ($Status);
1152
1153
1154 # Init the status
1155 $Status = 1;
1156
1157
1158 # Check that REQUEST_METHOD is specified
1159 if ( ! (defined($ENV{'REQUEST_METHOD'}) && ($ENV{'REQUEST_METHOD'} ne "")) ) {
1160 &vLog("Error - missing 'REQUEST_METHOD' environment variable.\n");
1161 $Status = 0;
1162 }
1163
1164
1165 # Check that SCRIPT_NAME is specified
1166 if ( ! (defined($ENV{'SCRIPT_NAME'}) && ($ENV{'SCRIPT_NAME'} ne "")) ) {
1167 &vLog("Error - missing 'SCRIPT_NAME' environment variable.\n");
1168 $Status = 0;
1169 }
1170
1171
1172 # Force guest
1173 #$ENV{'REMOTE_USER'} = "guest";
1174
1175 # Make sure that REMOTE_USER is defined, we set it to an empty string if it is not
1176 if ( ! (defined($ENV{'REMOTE_USER'}) && ($ENV{'REMOTE_USER'} ne "")) ) {
1177 $ENV{'REMOTE_USER'} = "";
1178 }
1179 else {
1180 # REMOTE_USER is defined, we check to see if the guest account name is defined
1181 if ( defined($main::ConfigurationData{'guest-account-name'}) ) {
1182 # Set the REMOTE_USER to an empty string if it is the same as the guest account
1183 if ( $ENV{'REMOTE_USER'} eq $main::ConfigurationData{'guest-account-name'} ) {
1184 $ENV{'REMOTE_USER'} = "";
1185 }
1186 }
1187 }
1188
1189
1190 # Adjust the path info if needed
1191 if ( defined($ENV{'PATH_INFO'}) && defined($ENV{'SCRIPT_NAME'}) && (length($ENV{'PATH_INFO'}) > length($ENV{'SCRIPT_NAME'})) ) {
1192 if ( substr($ENV{'PATH_INFO'}, 0, length($ENV{'SCRIPT_NAME'})) eq $ENV{'SCRIPT_NAME'} ) {
1193 $ENV{'PATH_INFO'} = substr($ENV{'PATH_INFO'}, length($ENV{'SCRIPT_NAME'}));
1194 $ENV{'PATH_INFO'} = undef if ($ENV{'PATH_INFO'} eq "");
1195 }
1196 }
1197
1198
1199 return ($Status);
1200
1201 }
1202
1203
1204
1205
1206 #--------------------------------------------------------------------------
1207 #
1208 # Function: bSetupCGIEnvironment()
1209 #
1210 # Purpose: This function sets up the environment for the CGI mode, it will
1211 # also check that all the globals are correct and that any
1212 # required directories can be accessed and written to
1213 #
1214 # An error here should be considered fatal.
1215 #
1216 # Called by:
1217 #
1218 # Parameters: void
1219 #
1220 # Global Variables: $main::UserAccountDirectoryPath, $main::UserSettingsFilePath, $main::RemoteUser,
1221 # %main::FormData, %main::ConfigurationData
1222 #
1223 # Returns: Boolean status
1224 #
1225 sub bSetupCGIEnvironment {
1226
1227 my ($Status, $URLString);
1228
1229
1230 # Init the status
1231 $Status = 1;
1232
1233
1234 # Get the query string from the environment
1235 if ( $ENV{'REQUEST_METHOD'} eq "GET" ) {
1236 $URLString = $ENV{'QUERY_STRING'};
1237 }
1238 # Get the query string from stdin
1239 elsif ( $ENV{'REQUEST_METHOD'} eq "POST" ) {
1240 read("STDIN", $URLString, $ENV{'CONTENT_LENGTH'});
1241
1242 # Append the query string if it is defined
1243 if ( defined($ENV{'QUERY_STRING'}) && ($ENV{'QUERY_STRING'} ne "") ) {
1244 $URLString = $ENV{'QUERY_STRING'} . "&". $URLString;
1245 }
1246 }
1247
1248
1249 # Parse the form data that was passed
1250 if ( defined($URLString) && ($URLString ne "") ) {
1251 %main::FormData = &hParseURLIntoHashTable($URLString);
1252 }
1253
1254
1255 # Get the REMOTE_USER from the CGI environment and set the user account directory path
1256 if ( (defined($ENV{'REMOTE_USER'})) && ($ENV{'REMOTE_USER'} ne "") && defined($main::ConfigurationData{'user-accounts-directory'}) ) {
1257 $main::RemoteUser = $ENV{'REMOTE_USER'};
1258 $main::UserAccountDirectoryPath = $main::ConfigurationData{'user-accounts-directory'} . "/". $main::RemoteUser;
1259 $main::UserAccountDirectoryPath =~ tr/\+/ /;
1260 $main::UserSettingsFilePath = $main::UserAccountDirectoryPath . "/". $main::UserSettingsFileName . $main::XMLFileNameExtension;
1261 }
1262 else {
1263 undef($main::RemoteUser);
1264 undef($main::UserAccountDirectoryPath);
1265 undef($main::UserSettingsFilePath);
1266 }
1267
1268
1269 # Check that the user account directory exists if it is specified
1270 if ( defined($main::UserAccountDirectoryPath) ) {
1271
1272 # Try to create the user account directory if it does not exist
1273 if ( ! -d $main::UserAccountDirectoryPath ) {
1274
1275 if ( mkdir($main::UserAccountDirectoryPath, 0700) ) {
1276
1277 # Set the user account directory so that it can be accessed by ourselves only
1278 chmod(0700, $main::UserAccountDirectoryPath);
1279
1280 }
1281 else {
1282
1283 # The directory could not be created, so we inform the user of the fact
1284 &vHandleError("User Account Error", "Sorry, the account directory could not be created");
1285 $Status = 0;
1286 }
1287 }
1288
1289
1290 # Check that we can access user account directory
1291 if ( ! ((-r $main::UserAccountDirectoryPath) && (-w $main::UserAccountDirectoryPath) && (-x $main::UserAccountDirectoryPath)) ) {
1292
1293 # The directory cannot be accessed, so we inform the user of the fact
1294 &vHandleError("User Account Error", "Sorry, the account directory could not be accessed");
1295 $Status = 0;
1296 }
1297 }
1298
1299
1300 return ($Status);
1301
1302 }
1303
1304
1305
1306
1307 #--------------------------------------------------------------------------
1308 #
1309 # Function: sMakeSearchURL()
1310 #
1311 # Purpose: This function makes a search URL from the passed content hash.
1312 #
1313 # Called by:
1314 #
1315 # Parameters: %Content content hash
1316 #
1317 # Global Variables: none
1318 #
1319 # Returns: the URL search string, and an empty string if
1320 # nothing relevant is defined in the content
1321 #
1322 sub sMakeSearchURL {
1323
1324 my (%Content) = @_;
1325
1326 my ($SearchURL, $Value);
1327 my (@InternalFieldNames) = ('Any', 'Operator', 'Past', 'Since', 'Before', 'LastRunTime', 'Order', 'Max', 'Database');
1328
1329
1330 # Initialize the search URL
1331 $SearchURL = "";
1332
1333
1334 # Add the generic field names
1335 foreach $Value ( 1..100 ) {
1336
1337 my ($FieldName) = "FieldName" . $Value;
1338 my ($FieldContent) = "FieldContent" . $Value;
1339
1340 if ( defined($Content{$FieldName}) ) {
1341 $SearchURL .= "&$FieldName=" . &lEncodeURLData($Content{$FieldName});
1342 $SearchURL .= defined($Content{$FieldContent}) ? "&$FieldContent=" . &lEncodeURLData($Content{$FieldContent}) : "";
1343 }
1344 }
1345
1346
1347 # Add the internal search terms
1348 foreach $Value ( @InternalFieldNames ) {
1349 $SearchURL .= defined($Content{$Value}) ? "&$Value=" . join("&$Value=", &lEncodeURLData(split(/\0/, $Content{$Value}))) : "";
1350 }
1351
1352
1353 # Return the URL, choping out the initial '&'
1354 return (($SearchURL ne "") ? substr($SearchURL, 1) : "");
1355
1356 }
1357
1358
1359
1360
1361
1362 #--------------------------------------------------------------------------
1363 #
1364 # Function: sMakeDocumentURL()
1365 #
1366 # Purpose: This function makes a document URL from the passed content hash.
1367 #
1368 # Called by:
1369 #
1370 # Parameters: %Content content hash
1371 #
1372 # Global Variables: none
1373 #
1374 # Returns: the URL document string, and an empty string if
1375 # nothing relevant is defined in the content
1376 #
1377 sub sMakeDocumentURL {
1378
1379 my (%Content) = @_;
1380
1381 my ($DocumentURL);
1382
1383
1384 # Initialize the document URL
1385 $DocumentURL = "";
1386
1387
1388 # Add the document URLs
1389 if ( defined($Content{'Document'}) ) {
1390 $DocumentURL .= "&Document=" . join("&Document=", &lEncodeURLData(split(/\0/, $Content{'Document'})));
1391 }
1392
1393
1394 # Return the URL, choping out the initial '&'
1395 return (($DocumentURL ne "") ? substr($DocumentURL, 1) : "");
1396
1397 }
1398
1399
1400
1401
1402
1403 #--------------------------------------------------------------------------
1404 #
1405 # Function: sMakeRfDocumentURL()
1406 #
1407 # Purpose: This function makes an RF document URL from the passed content hash.
1408 #
1409 # Called by:
1410 #
1411 # Parameters: %Content content hash
1412 #
1413 # Global Variables: none
1414 #
1415 # Returns: the URL RF document string, and an empty string if
1416 # nothing relevant is defined in the content
1417 #
1418 sub sMakeRfDocumentURL {
1419
1420 my (%Content) = @_;
1421
1422 my ($RfDocumentURL);
1423
1424
1425 # Initialize the RF document URL
1426 $RfDocumentURL = "";
1427
1428
1429 # Add the RF document URLs
1430 if ( defined($Content{'RfDocument'}) ) {
1431 $RfDocumentURL .= "&RfDocument=" . join("&RfDocument=", &lEncodeURLData(split(/\0/, $Content{'RfDocument'})));
1432 }
1433
1434
1435 # Return the URL, choping out the initial '&'
1436 return (($RfDocumentURL ne "") ? substr($RfDocumentURL, 1) : "");
1437
1438 }
1439
1440
1441
1442
1443
1444 #--------------------------------------------------------------------------
1445 #
1446 # Function: sMakeSearchAndRfDocumentURL()
1447 #
1448 # Purpose: This function makes a URL string from the search
1449 # and RF document URLs
1450 #
1451 # Called by:
1452 #
1453 # Parameters: %Content content hash
1454 #
1455 # Global Variables: none
1456 #
1457 # Returns: the URL query string, and an empty string if
1458 # nothing relevant is defined in %Content
1459 #
1460 sub sMakeSearchAndRfDocumentURL {
1461
1462 my (%Content) = @_;
1463
1464 my ($SearchURL, $RfDocumentURL, $SearchRfDocumentURL);
1465
1466
1467 # Get the search URL and the RF document URL
1468 $SearchURL = &sMakeSearchURL(%Content);
1469 $RfDocumentURL = &sMakeRfDocumentURL(%Content);
1470
1471
1472 # Concatenate them intelligently
1473 $SearchRfDocumentURL = $SearchURL . ((($SearchURL ne "") && ($RfDocumentURL ne "")) ? "&" : "") . $RfDocumentURL;
1474
1475
1476 # Return the URL
1477 return ($SearchRfDocumentURL);
1478
1479 }
1480
1481
1482
1483
1484 #--------------------------------------------------------------------------
1485 #
1486 # Function: sMakeSearchString()
1487 #
1488 # Purpose: This function makes a search string from the search
1489 # variables in the content hash
1490 #
1491 # Called by:
1492 #
1493 # Parameters: %Content content hash
1494 #
1495 # Global Variables: void
1496 #
1497 # Returns: the search string, and an empty string if
1498 # nothing relevant is defined in the content hash
1499 #
1500 sub sMakeSearchString {
1501
1502 my (%Content) = @_;
1503
1504 my ($SearchString);
1505 my ($FieldName, $Time, $Date);
1506 my ($Value);
1507
1508
1509 # Initialize the search string
1510 $SearchString = "";
1511
1512
1513 # Add the search terms
1514 $SearchString .= defined($Content{'Any'}) ? ((($SearchString ne "") ? " AND " : "") . $Content{'Any'}) : "";
1515
1516
1517 # Add the generic field names
1518 foreach $Value ( 1..100 ) {
1519
1520 my ($FieldName) = "FieldName" . $Value;
1521 my ($FieldContent) = "FieldContent" . $Value;
1522
1523
1524 if ( defined($Content{$FieldName}) && 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 }
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 # defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
1962 $Title);
1963 }
1964 else {
1965 # printf("%s%s:\n", defined($Title) ? $Title : "Document", (scalar(@Documents) > 1) ? "s" : "");
1966 print $Title;
1967 }
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 # decode some basic html from headline <b> <i>
1988 $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;
1989
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 # 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
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
2085
2086 # 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 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
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 print("<OPTION VALUE=\"GetSaveSearch\">Saèuvaj upit\n");
2216 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 ### FIX:: ADD SORT HERE
2403 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 #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 # decode some basic html from headline <b> <i>
2661 $Headline =~ s/&lt;(\/?[bi])&gt;/<$1>/g;
2662
2663 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 printf("%3d $Headline \n", $Score);
2666 }
2667
2668 if (0) { ## don't display description
2669
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
2686 }
2687 else {
2688 print(" Format: $MimeTypeName, ");
2689 }
2690 }
2691
2692
2693 # Put up the date if we got it
2694 if ( defined($Date) && ($Date ne "") ) {
2695 print("Date: $Date");
2696
2697 # Put up the time if we got it
2698 if ( defined($Time) && ($Time ne "") ) {
2699 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 } #if
2830 # 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 $Value = ($ENV{'PATH_INFO'} eq "/GetExpandedSearch") ? "Slo¾eno pretra¾ivanje" : "Jednostavno pretra¾ivanje";
2945
2946 &vSendHTMLHeader($Value, $main::JavaScript_SetChecked);
2947
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 print("<INPUT SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'collapse'}\" BORDER=0 TYPE=IMAGE> Jednostavo pretra¾ivanje (kliknite na trokutiæ)\n");
2986 }
2987 else {
2988 print("<INPUT TYPE=HIDDEN NAME=\"Action\" VALUE=\"GetExpandedSearch\">\n");
2989 print("<INPUT SRC=\"$main::ConfigurationData{'image-base-path'}/$main::ImageNames{'expand'}\" BORDER=0 TYPE=IMAGE> Slo¾eno pretra¾ivanje (kliknite na trokutiæ)\n");
2990 }
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 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 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 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
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 print "<TR>";
3018 if ($field == 1 ) {
3019 print "<TD ALIGN=LEFT VALIGN=TOP ROWSPAN=$nr_fields>";
3020 print "Pretra¾i u odabranom polju:";
3021 print "</td>";
3022 }
3023 print ("<TD ALIGN=RIGHT VALIGN=TOP>");
3024
3025 print ("<SELECT NAME=\"FieldName${field}\">");
3026 for (my $i=0; $i<=$#SearchFieldNames; $i++) {
3027 my $ItemEntry = $SearchFieldNames[$i];
3028 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 print("<OPTION VALUE=\"$ItemEntry\" $Selected> $main::SearchFieldDescriptions{$ItemEntry}\n");
3036 }
3037 my $Value = "";
3038 if (defined($main::FormData{"FieldContent${field}"})) {
3039 $Value = "VALUE='".$main::FormData{"FieldContent${field}"}."'";
3040 }
3041 print("</SELECT></TD><TD ALIGN=LEFT VALIGN=TOP><INPUT NAME=\"FieldContent${field}\" TYPE=TEXT $Value SIZE=45> </TD></TR>\n");
3042 }
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 print("<TR><TD ALIGN=LEFT VALIGN=TOP COLSPAN=2> Odaberite knji¾nicu èiji fond ¾elite pretra¾ivati:</TD></TR>
3064 <TR><TD ALIGN=CENTER VALIGN=TOP COLSPAN=4>
3065 ");
3066
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 &ShowDatabaseCheckBoxes(@ItemList);
3081
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 ### FIX:: SORT
3169 # print("<OPTION VALUE=\"SORT:700+:DESC\"> autor\n");
3170 # print("<OPTION VALUE=\"SORT:200+:DESC\"> naslov\n");
3171 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 print("<H3>Pretra¾ivanje baza:</H3>\n");
3289 print("<H3><CENTER>Niste odabrali knji¾nicu koju ¾elite pretra¾ivati.</CENTER></H3>\n");
3290 print("<P>\n");
3291 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 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 &vSendHTMLHeader("My Settings", $main::JavaScript_SetChecked);
3966 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 print("<FORM ACTION=\"$ENV{'SCRIPT_NAME'}/SetUserSettings\" NAME=\"Search\" METHOD=POST>\n");
4004
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 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
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
4073 &ShowDatabaseCheckBoxes(@ItemList);
4074
4075 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 $Value{'SelectedDatabases'} = $main::FormData{'Database'};
4219 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 print("<H3> Èuvanje upita: </H3>\n");
4647
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 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
4701 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
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 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
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 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
4723 # Send a pull-down which allows the user to select the automatic search frequency
4724 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite frekvenciju automatskog pretra¾ivanja: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"SearchFrequency\">\n");
4725 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 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 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 print("<TR><TD ALIGN=LEFT VALIGN=TOP> Odaberite metodu isporuke: </TD> <TD ALIGN=LEFT VALIGN=TOP> <SELECT NAME=\"DeliveryMethod\">\n");
4741 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 print("<H3> Èuvanje upita: </H3>\n");
4862 print("<H3><CENTER> Veæ postoji upit pod ovim imenom. </CENTER></H3>\n");
4863 print("<P>\n");
4864 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 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 print("<H3> Èuvanje upita: </H3>\n");
4880 print("<H3><CENTER> E-mail adresa nije specificirana u va¹im postavkama. </CENTER></H3>\n");
4881 print("<P>\n");
4882 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 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 print("<H3> Saèuvani upiti: </H3>\n");
5013
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 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 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 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 }
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 $Title = "Brisanje saèuvanih pretra¾ivanja";
5266 }
5267 elsif ( $ENV{'PATH_INFO'} eq "/ActivateSavedSearch" ) {
5268 $Title = "Ukljuèivanje automatskog periodiènog pretra¾ivanja";
5269 }
5270 elsif ( $ENV{'PATH_INFO'} eq "/SuspendSavedSearch" ) {
5271 $Title = "Iskljuèivanje automatskog periodiènog pretra¾ivanja";
5272 }
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 print("<H3><CENTER>Niste odabrali niti jedan upit. </CENTER></H3>\n");
5287 print("<P>\n");
5288 print("Potrebno je odabrati barem jedan saèuvani upit nad kojim æe se izvr¹iti akcija.\n");
5289 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 printf("<P>Uspje¹no pobrisano: %s\n", $Value{'SearchName'});
5318 }
5319 else {
5320 printf("<P>Nije pobrisano: %s\n", $Value{'SearchName'});
5321 }
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 printf("<P>Uspje¹no %s: %s\n",
5335 ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "ukljuèeno" : "iskljuèeno", $Value{'SearchName'});
5336 }
5337 else {
5338 printf("<P>Nije %s: %s\n",
5339 ($ENV{'PATH_INFO'} eq "/ActivateSavedSearch") ? "ukljuèeno" : "iskljuèeno", $Value{'SearchName'});
5340 }
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 print("<H3> Kreiranje korisnièkog foldera: </H3>\n");
5442
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 ###FIX
5491 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 print("<H3> Korisnièki folderi: </H3>\n");
5902
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 if ( defined($main::FormData{'GetSearch'}) ) {
7113 $ENV{'PATH_INFO'} = "/GetSearch";
7114 delete($main::FormData{'GetSearch'});
7115 delete($main::FormData{'GetSearch'});
7116 }
7117
7118 if ( defined($main::FormData{'ListSearchHistory'}) ) {
7119 $ENV{'PATH_INFO'} = "/ListSearchHistory";
7120 delete($main::FormData{'ListSearchHistory'});
7121 delete($main::FormData{'ListSearchHistory'});
7122 }
7123
7124 if ( defined($main::FormData{'ListSavedSearch'}) ) {
7125 $ENV{'PATH_INFO'} = "/ListSavedSearch";
7126 delete($main::FormData{'ListSavedSearch'});
7127 delete($main::FormData{'ListSavedSearch'});
7128 }
7129
7130 if ( defined($main::FormData{'ListFolder'}) ) {
7131 $ENV{'PATH_INFO'} = "/ListFolder";
7132 delete($main::FormData{'ListFolder'});
7133 delete($main::FormData{'ListFolder'});
7134 }
7135
7136 if ( defined($main::FormData{'GetUserSettings'}) ) {
7137 $ENV{'PATH_INFO'} = "/GetUserSettings";
7138 delete($main::FormData{'GetUserSettings'});
7139 delete($main::FormData{'GetUserSettings'});
7140 }
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 }
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 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
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 }

  ViewVC Help
Powered by ViewVC 1.1.26