/[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.18 - (show annotations)
Tue Jun 25 17:04:18 2002 UTC (21 years, 9 months ago) by dpavlin
Branch: MAIN
Changes since 1.17: +7 -7 lines
Prijevod

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

  ViewVC Help
Powered by ViewVC 1.1.26