catalogue/search.pl

   1 #!/usr/bin/perl
   2 # Script to perform searching
   3 # For documentation try 'perldoc /path/to/search'
   4 #
   5 # Copyright 2006 LibLime
   6 # Copyright 2010 BibLibre
   7 #
   8 # This file is part of Koha
   9 #
  10 # Koha is free software; you can redistribute it and/or modify it
  11 # under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 3 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # Koha is distributed in the hope that it will be useful, but
  16 # WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  22
  23 =head1 NAME
  24
  25 search - a search script for finding records in a Koha system (Version 3)
  26
  27 =head1 OVERVIEW
  28
  29 This script utilizes a new search API for Koha 3. It is designed to be
  30 simple to use and configure, yet capable of performing feats like stemming,
  31 field weighting, relevance ranking, support for multiple  query language
  32 formats (CCL, CQL, PQF), full support for the bib1 attribute set, extended
  33 attribute sets defined in Zebra profiles, access to the full range of Z39.50
  34 and SRU query options, federated searches on Z39.50/SRU targets, etc.
  35
  36 The API as represented in this script is mostly sound, even if the individual
  37 functions in Search.pm and Koha.pm need to be cleaned up. Of course, you are
  38 free to disagree :-)
  39
  40 I will attempt to describe what is happening at each part of this script.
  41 -- Joshua Ferraro <jmf AT liblime DOT com>
  42
  43 =head2 INTRO
  44
  45 This script performs two functions:
  46
  47 =over
  48
  49 =item 1. interacts with Koha to retrieve and display the results of a search
  50
  51 =item 2. loads the advanced search page
  52
  53 =back
  54
  55 These two functions share many of the same variables and modules, so the first
  56 task is to load what they have in common and determine which template to use.
  57 Once determined, proceed to only load the variables and procedures necessary
  58 for that function.
  59
  60 =head2 LOADING ADVANCED SEARCH PAGE
  61
  62 This is fairly straightforward, and I won't go into detail ;-)
  63
  64 =head2 PERFORMING A SEARCH
  65
  66 If we're performing a search, this script  performs three primary
  67 operations:
  68
  69 =over
  70
  71 =item 1. builds query strings (yes, plural)
  72
  73 =item 2. perform the search and return the results array
  74
  75 =item 3. build the HTML for output to the template
  76
  77 =back
  78
  79 There are several additional secondary functions performed that I will
  80 not cover in detail.
  81
  82 =head3 1. Building Query Strings
  83
  84 There are several types of queries needed in the process of search and retrieve:
  85
  86 =over
  87
  88 =item 1 $query - the fully-built query passed to zebra
  89
  90 This is the most complex query that needs to be built. The original design goal
  91 was to use a custom CCL2PQF query parser to translate an incoming CCL query into
  92 a multi-leaf query to pass to Zebra. It needs to be multi-leaf to allow field
  93 weighting, koha-specific relevance ranking, and stemming. When I have a chance
  94 I'll try to flesh out this section to better explain.
  95
  96 This query incorporates query profiles that aren't compatible with most non-Zebra
  97 Z39.50 targets to accomplish the field weighting and relevance ranking.
  98
  99 =item 2 $simple_query - a simple query that doesn't contain the field weighting,
 100 stemming, etc., suitable to pass off to other search targets
 101
 102 This query is just the user's query expressed in CCL CQL, or PQF for passing to a
 103 non-zebra Z39.50 target (one that doesn't support the extended profile that Zebra does).
 104
 105 =item 3 $query_cgi - passed to the template / saved for future refinements of
 106 the query (by user)
 107
 108 This is a simple string that completely expresses the query as a CGI string that
 109 can be used for future refinements of the query or as a part of a history feature.
 110
 111 =item 4 $query_desc - Human search description - what the user sees in search
 112 feedback area
 113
 114 This is a simple string that is human readable. It will contain '=', ',', etc.
 115
 116 =back
 117
 118 =head3 2. Perform the Search
 119
 120 This section takes the query strings and performs searches on the named servers,
 121 including the Koha Zebra server, stores the results in a deeply nested object,
 122 builds 'faceted results', and returns these objects.
 123
 124 =head3 3. Build HTML
 125
 126 The final major section of this script takes the objects collected thusfar and
 127 builds the HTML for output to the template and user.
 128
 129 =head3 Additional Notes
 130
 131 Not yet completed...
 132
 133 =cut
 134
 135 use Modern::Perl;
 136
 137 ## STEP 1. Load things that are used in both search page and
 138 # results page and decide which template to load, operations
 139 # to perform, etc.
 140
 141 ## load Koha modules
 142 use C4::Context;
 143 use C4::Output;
 144 use C4::Auth qw(:DEFAULT get_session);
 145 use C4::Search;
 146 use C4::Languages qw(getLanguages);
 147 use C4::Koha;
 148 use URI::Escape;
 149 use POSIX qw(ceil floor);
 150 use C4::Search::History;
 151
 152 use Koha::ItemTypes;
 153 use Koha::Library::Groups;
 154 use Koha::Patrons;
 155 use Koha::SearchEngine::Search;
 156 use Koha::SearchEngine::QueryBuilder;
 157 use Koha::Virtualshelves;
 158 use Koha::SearchFields;
 159
 160 use URI::Escape;
 161
 162 my $DisplayMultiPlaceHold = C4::Context->preference("DisplayMultiPlaceHold");
 163 # create a new CGI object
 164 # FIXME: no_undef_params needs to be tested
 165 use CGI qw('-no_undef_params' -utf8 );
 166 my $cgi = new CGI;
 167
 168 # decide which template to use
 169 my $template_name;
 170 my $template_type;
 171 my @params = $cgi->multi_param("limit");
 172 if ((@params>=1) || ($cgi->param("q")) || ($cgi->param('multibranchlimit')) || ($cgi->param('limit-yr')) ) {
 173     $template_name = 'catalogue/results.tt';
 174     $template_type = 'results';
 175 }
 176 else {
 177     $template_name = 'catalogue/advsearch.tt';
 178     $template_type = 'advsearch';
 179 }
 180 # load the template
 181 my ($template, $borrowernumber, $cookie) = get_template_and_user({
 182     template_name => $template_name,
 183     query => $cgi,
 184     type => "intranet",
 185     flagsrequired   => { catalogue => 1 },
 186     }
 187 );
 188
 189 my $lang = C4::Languages::getlanguage($cgi);
 190
 191 if (C4::Context->preference("marcflavour") eq "UNIMARC" ) {
 192     $template->param('UNIMARC' => 1);
 193 }
 194
 195 if($cgi->cookie("holdfor")){
 196     my $holdfor_patron = Koha::Patrons->find( $cgi->cookie("holdfor") );
 197     $template->param(
 198         holdfor => $cgi->cookie("holdfor"),
 199         holdfor_surname => $holdfor_patron->surname,
 200         holdfor_firstname => $holdfor_patron->firstname,
 201         holdfor_cardnumber => $holdfor_patron->cardnumber,
 202     );
 203 }
 204
 205 if($cgi->cookie("holdforclub")){
 206     my $holdfor_club = Koha::Clubs->find( $cgi->cookie("holdforclub") );
 207     $template->param(
 208         holdforclub => $cgi->cookie("holdforclub"),
 209         holdforclub_name => $holdfor_club->name,
 210     );
 211 }
 212
 213 # get biblionumbers stored in the cart
 214 my @cart_list;
 215
 216 if($cgi->cookie("intranet_bib_list")){
 217     my $cart_list = $cgi->cookie("intranet_bib_list");
 218     @cart_list = split(/\//, $cart_list);
 219 }
 220
 221 my @search_groups =
 222   Koha::Library::Groups->get_search_groups( { interface => 'staff' } );
 223 @search_groups = sort { $a->title cmp $b->title } @search_groups;
 224
 225 $template->param(
 226     selected_branchcode => ( C4::Context->IsSuperLibrarian ? C4::Context->userenv : '' ),
 227     search_groups    => \@search_groups,
 228 );
 229
 230 # load the Type stuff
 231 my $itemtypes = { map { $_->{itemtype} => $_ } @{ Koha::ItemTypes->search_with_localization->unblessed } };
 232 # the index parameter is different for item-level itemtypes
 233 my $itype_or_itemtype = (C4::Context->preference("item-level_itypes"))?'itype':'itemtype';
 234 my @advancedsearchesloop;
 235 my $cnt;
 236 my $advanced_search_types = C4::Context->preference("AdvancedSearchTypes") || "itemtypes";
 237 my @advanced_search_types = split(/\|/, $advanced_search_types);
 238
 239 foreach my $advanced_srch_type (@advanced_search_types) {
 240     $advanced_srch_type =~ s/^\s*//;
 241     $advanced_srch_type =~ s/\s*$//;
 242    if ($advanced_srch_type eq 'itemtypes') {
 243    # itemtype is a special case, since it's not defined in authorized values
 244         my @itypesloop;
 245         foreach my $thisitemtype ( sort {$itemtypes->{$a}->{translated_description} cmp $itemtypes->{$b}->{translated_description} } keys %$itemtypes ) {
 246             my %row =(  number=>$cnt++,
 247                 ccl => "$itype_or_itemtype,phr",
 248                 code => $thisitemtype,
 249                 description => $itemtypes->{$thisitemtype}->{translated_description},
 250                 imageurl=> getitemtypeimagelocation( 'intranet', $itemtypes->{$thisitemtype}->{'imageurl'} ),
 251             );
 252             push @itypesloop, \%row;
 253         }
 254         my %search_code = (  advanced_search_type => $advanced_srch_type,
 255                              code_loop => \@itypesloop );
 256         push @advancedsearchesloop, \%search_code;
 257     } else {
 258     # covers all the other cases: non-itemtype authorized values
 259        my $advsearchtypes = GetAuthorisedValues($advanced_srch_type);
 260         my @authvalueloop;
 261         for my $thisitemtype (@$advsearchtypes) {
 262                 my %row =(
 263                                 number=>$cnt++,
 264                                 ccl => $advanced_srch_type,
 265                 code => $thisitemtype->{authorised_value},
 266                 description => $thisitemtype->{'lib'},
 267                 imageurl => getitemtypeimagelocation( 'intranet', $thisitemtype->{'imageurl'} ),
 268                 );
 269                 push @authvalueloop, \%row;
 270         }
 271         my %search_code = (  advanced_search_type => $advanced_srch_type,
 272                              code_loop => \@authvalueloop );
 273         push @advancedsearchesloop, \%search_code;
 274     }
 275 }
 276 $template->param(advancedsearchesloop => \@advancedsearchesloop);
 277 my $types = C4::Context->preference("AdvancedSearchTypes") || "itemtypes";
 278 my $advancedsearchesloop = prepare_adv_search_types($types);
 279 $template->param(advancedsearchesloop => $advancedsearchesloop);
 280
 281 # The following should only be loaded if we're bringing up the advanced search template
 282 if ( $template_type eq 'advsearch' ) {
 283
 284     # load the servers (used for searching -- to do federated searching, etc.)
 285     my $primary_servers_loop;# = displayPrimaryServers();
 286     $template->param(outer_servers_loop =>  $primary_servers_loop,);
 287
 288     my $secondary_servers_loop;
 289     $template->param(outer_sup_servers_loop => $secondary_servers_loop,);
 290
 291     # set the default sorting
 292     if (   C4::Context->preference('defaultSortField')
 293         && C4::Context->preference('defaultSortOrder') ) {
 294         my $default_sort_by =
 295             C4::Context->preference('defaultSortField') . '_'
 296           . C4::Context->preference('defaultSortOrder');
 297         $template->param( sort_by => $default_sort_by  );
 298     }
 299
 300     # determine what to display next to the search boxes (ie, boolean option
 301     # shouldn't appear on the first one, scan indexes should, adding a new
 302     # box should only appear on the last, etc.
 303     my @search_boxes_array;
 304     my $search_boxes_count = 3; # begin with 3 boxes
 305     # FIXME: all this junk can be done in TMPL using __first__ and __last__
 306     for (my $i=1;$i<=$search_boxes_count;$i++) {
 307         # if it's the first one, don't display boolean option, but show scan indexes
 308         if ($i==1) {
 309             push @search_boxes_array, {scan_index => 1};
 310         }
 311         # if it's the last one, show the 'add field' box
 312         elsif ($i==$search_boxes_count) {
 313             push @search_boxes_array,
 314                 {
 315                 boolean => 1,
 316                 add_field => 1,
 317                 };
 318         }
 319         else {
 320             push @search_boxes_array,
 321                 {
 322                 boolean => 1,
 323                 };
 324         }
 325
 326     }
 327     $template->param(uc(C4::Context->preference("marcflavour")) => 1,
 328                       search_boxes_loop => \@search_boxes_array);
 329
 330     # load the language limits (for search)
 331     my $languages_limit_loop = getLanguages($lang, 1);
 332     $template->param(search_languages_loop => $languages_limit_loop,);
 333
 334     # Expanded search options in advanced search:
 335     # use the global setting by default, but let the user override it
 336     {
 337         my $expanded = $cgi->param('expanded_options');
 338         $expanded = C4::Context->preference("expandedSearchOption") || 0
 339             if !defined($expanded) || $expanded !~ /^0|1$/;
 340         $template->param( expanded_options => $expanded );
 341     }
 342
 343     $template->param(virtualshelves => C4::Context->preference("virtualshelves"));
 344
 345     output_html_with_http_headers $cgi, $cookie, $template->output;
 346     exit;
 347 }
 348
 349 ### OK, if we're this far, we're performing a search, not just loading the advanced search page
 350
 351 # Fetch the paramater list as a hash in scalar context:
 352 #  * returns paramater list as tied hash ref
 353 #  * we can edit the values by changing the key
 354 #  * multivalued CGI paramaters are returned as a packaged string separated by "\0" (null)
 355 my $params = $cgi->Vars;
 356 # Params that can have more than one value
 357 # sort by is used to sort the query
 358 # in theory can have more than one but generally there's just one
 359 my @sort_by;
 360 my $default_sort_by;
 361 if (   C4::Context->preference('defaultSortField')
 362     && C4::Context->preference('defaultSortOrder') ) {
 363     $default_sort_by =
 364         C4::Context->preference('defaultSortField') . '_'
 365       . C4::Context->preference('defaultSortOrder');
 366 }
 367
 368 @sort_by = $cgi->multi_param('sort_by');
 369 $sort_by[0] = $default_sort_by unless $sort_by[0];
 370 foreach my $sort (@sort_by) {
 371     $template->param($sort => 1) if $sort;
 372 }
 373 $template->param('sort_by' => $sort_by[0]);
 374
 375 # Use the servers defined, or just search our local catalog(default)
 376 my @servers = $cgi->multi_param('server');
 377 unless (@servers) {
 378     #FIXME: this should be handled using Context.pm
 379     @servers = ("biblioserver");
 380     # @servers = C4::Context->config("biblioserver");
 381 }
 382 # operators include boolean and proximity operators and are used
 383 # to evaluate multiple operands
 384 my @operators = map uri_unescape($_), $cgi->multi_param('op');
 385
 386 # indexes are query qualifiers, like 'title', 'author', etc. They
 387 # can be single or multiple parameters separated by comma: kw,right-Truncation
 388 my @indexes = map uri_unescape($_), $cgi->multi_param('idx');
 389
 390 # if a simple index (only one)  display the index used in the top search box
 391 if ($indexes[0] && (!$indexes[1] || $params->{'scan'})) {
 392     my $idx = "ms_".$indexes[0];
 393     $idx =~ s/\,/comma/g;  # template toolkit doesn't like variables with a , in it
 394     $idx =~ s/-/dash/g;  # template toolkit doesn't like variables with a dash in it
 395     $template->param($idx => 1);
 396 }
 397
 398 # an operand can be a single term, a phrase, or a complete ccl query
 399 my @operands = map uri_unescape($_), $cgi->multi_param('q');
 400
 401 # if a simple search, display the value in the search box
 402 if ($operands[0] && !$operands[1]) {
 403     my $ms_query = $operands[0];
 404     $ms_query =~ s/ #\S+//;
 405     $template->param(ms_value => $ms_query);
 406 }
 407
 408 # limits are use to limit to results to a pre-defined category such as branch or language
 409 my @limits = map uri_unescape($_), $cgi->multi_param('limit');
 410 my @nolimits = map uri_unescape($_), $cgi->multi_param('nolimit');
 411 my %is_nolimit = map { $_ => 1 } @nolimits;
 412 @limits = grep { not $is_nolimit{$_} } @limits;
 413
 414 if($params->{'multibranchlimit'}) {
 415     my $search_group = Koha::Library::Groups->find( $params->{multibranchlimit} );
 416     my @libraries = $search_group->all_libraries;
 417     my $multibranch = '('.join( " OR ", map { '(homebranch: ' . $_->branchcode .')' } @libraries ) .')';
 418     push @limits, $multibranch if ($multibranch ne  '()');
 419 }
 420
 421 my $available;
 422 foreach my $limit(@limits) {
 423     if ($limit =~/available/) {
 424         $available = 1;
 425     }
 426 }
 427 $template->param(available => $available);
 428
 429 # append year limits if they exist
 430 my $limit_yr;
 431 my $limit_yr_value;
 432 if ($params->{'limit-yr'}) {
 433     if ($params->{'limit-yr'} =~ /\d{4}/) {
 434         $limit_yr = "yr,st-numeric=$params->{'limit-yr'}";
 435         $limit_yr_value = $params->{'limit-yr'};
 436     }
 437     push @limits,$limit_yr;
 438     #FIXME: Should return a error to the user, incorect date format specified
 439 }
 440
 441 # convert indexes and operands to corresponding parameter names for the z3950 search
 442 # $ %z3950p will be a hash ref if the indexes are present (advacned search), otherwise undef
 443 my $z3950par;
 444 my $indexes2z3950 = {
 445     kw=>'title', au=>'author', 'au,phr'=>'author', nb=>'isbn', ns=>'issn',
 446     'lcn,phr'=>'dewey', su=>'subject', 'su,phr'=>'subject',
 447     ti=>'title', 'ti,phr'=>'title', se=>'title'
 448 };
 449 for (my $ii = 0; $ii < @operands; ++$ii)
 450 {
 451     my $name = $indexes2z3950->{$indexes[$ii] || 'kw'};
 452     if (defined $name && defined $operands[$ii])
 453     {
 454         $z3950par ||= {};
 455         $z3950par->{$name} = $operands[$ii] if !exists $z3950par->{$name};
 456     }
 457 }
 458
 459
 460 # Params that can only have one value
 461 my $scan = $params->{'scan'};
 462 my $count = C4::Context->preference('numSearchResults') || 20;
 463 my $results_per_page = $params->{'count'} || $count;
 464 my $offset = $params->{'offset'} || 0;
 465 my $whole_record = $params->{'whole_record'} || 0;
 466 $offset = 0 if $offset < 0;
 467 my $page = $cgi->param('page') || 1;
 468 #my $offset = ($page-1)*$results_per_page;
 469
 470 # Define some global variables
 471 my ( $error,$query,$simple_query,$query_cgi,$query_desc,$limit,$limit_cgi,$limit_desc,$query_type);
 472
 473 my $builder = Koha::SearchEngine::QueryBuilder->new(
 474     { index => $Koha::SearchEngine::BIBLIOS_INDEX } );
 475 my $searcher = Koha::SearchEngine::Search->new(
 476     { index => $Koha::SearchEngine::BIBLIOS_INDEX } );
 477
 478 ## I. BUILD THE QUERY
 479 (
 480     $error,             $query, $simple_query, $query_cgi,
 481     $query_desc,        $limit, $limit_cgi,    $limit_desc,
 482     $query_type
 483   )
 484   = $builder->build_query_compat( \@operators, \@operands, \@indexes, \@limits,
 485     \@sort_by, $scan, $lang, { weighted_fields => !$cgi->param('advsearch'), whole_record => $whole_record });
 486
 487 $template->param( search_query => $query ) if C4::Context->preference('DumpSearchQueryTemplate');
 488
 489 ## parse the query_cgi string and put it into a form suitable for <input>s
 490 my @query_inputs;
 491 my $scan_index_to_use;
 492 my $scan_search_term_to_use;
 493
 494 if ($query_cgi) {
 495     for my $this_cgi ( split('&', $query_cgi) ) {
 496         next unless $this_cgi;
 497         $this_cgi =~ m/(.*?)=(.*)/;
 498         my $input_name = $1;
 499         my $input_value = $2;
 500         push @query_inputs, { input_name => $input_name, input_value => Encode::decode_utf8( uri_unescape( $input_value ) ) };
 501         if ($input_name eq 'idx') {
 502             # The form contains multiple fields, so take the first value as the scan index
 503             $scan_index_to_use = $input_value unless $scan_index_to_use;
 504         }
 505         if (!defined $scan_search_term_to_use && $input_name eq 'q') {
 506             $scan_search_term_to_use = Encode::decode_utf8( uri_unescape( $input_value ));
 507         }
 508     }
 509 }
 510
 511 $template->param ( QUERY_INPUTS => \@query_inputs,
 512                    scan_index_to_use => $scan_index_to_use,
 513                    scan_search_term_to_use => $scan_search_term_to_use );
 514
 515 ## parse the limit_cgi string and put it into a form suitable for <input>s
 516 my @limit_inputs;
 517 if ($limit_cgi) {
 518     for my $this_cgi ( split('&', $limit_cgi) ) {
 519         next unless $this_cgi;
 520         # handle special case limit-yr
 521         if ($this_cgi =~ /yr,st-numeric/) {
 522             push @limit_inputs, { input_name => 'limit-yr', input_value => $limit_yr_value };
 523             next;
 524         }
 525         $this_cgi =~ m/(.*=)(.*)/;
 526         my $input_name = $1;
 527         my $input_value = $2;
 528         $input_name =~ s/=$//;
 529         push @limit_inputs, { input_name => $input_name, input_value => Encode::decode_utf8( uri_unescape($input_value) ) };
 530     }
 531 }
 532 $template->param ( LIMIT_INPUTS => \@limit_inputs );
 533
 534 ## II. DO THE SEARCH AND GET THE RESULTS
 535 my $total = 0; # the total results for the whole set
 536 my $facets; # this object stores the faceted results that display on the left-hand of the results page
 537 my $results_hashref;
 538
 539 eval {
 540     my $itemtypes = { map { $_->{itemtype} => $_ } @{ Koha::ItemTypes->search_with_localization->unblessed } };
 541     ( $error, $results_hashref, $facets ) = $searcher->search_compat(
 542         $query,            $simple_query, \@sort_by,       \@servers,
 543         $results_per_page, $offset,       undef,           $itemtypes,
 544         $query_type,       $scan
 545     );
 546 };
 547
 548 if ($@ || $error) {
 549     $template->param(query_error => $error.$@);
 550     output_html_with_http_headers $cgi, $cookie, $template->output;
 551     exit;
 552 }
 553
 554 # At this point, each server has given us a result set
 555 # now we build that set for template display
 556 my @sup_results_array;
 557 for (my $i=0;$i<@servers;$i++) {
 558     my $server = $servers[$i];
 559     if ($server =~/biblioserver/) { # this is the local bibliographic server
 560         my $hits = $results_hashref->{$server}->{"hits"} // 0;
 561         my $page = $cgi->param('page') || 0;
 562         my @newresults = searchResults({ 'interface' => 'intranet' }, $query_desc, $hits, $results_per_page, $offset, $scan,
 563                                        $results_hashref->{$server}->{"RECORDS"});
 564         $total = $total + $hits;
 565
 566         # Search history
 567         if (C4::Context->preference('EnableSearchHistory')) {
 568             unless ( $offset ) {
 569                 my $path_info = $cgi->url(-path_info=>1);
 570                 my $query_cgi_history = $cgi->url(-query=>1);
 571                 $query_cgi_history =~ s/^$path_info\?//;
 572                 $query_cgi_history =~ s/;/&/g;
 573                 my $query_desc_history = $query_desc;
 574                 $query_desc_history .= ", $limit_desc"
 575                     if $limit_desc;
 576
 577                 C4::Search::History::add({
 578                     userid => $borrowernumber,
 579                     sessionid => $cgi->cookie("CGISESSID"),
 580                     query_desc => $query_desc_history,
 581                     query_cgi => $query_cgi_history,
 582                     total => $total,
 583                     type => "biblio",
 584                 });
 585             }
 586             $template->param( EnableSearchHistory => 1 );
 587         }
 588
 589         ## If there's just one result, redirect to the detail page unless doing an index scan
 590         if ($total == 1 && !$scan) {
 591             my $biblionumber = $newresults[0]->{biblionumber};
 592             my $defaultview = C4::Context->preference('IntranetBiblioDefaultView');
 593             my $views = { C4::Search::enabled_staff_search_views };
 594             if ($defaultview eq 'isbd' && $views->{can_view_ISBD}) {
 595                 print $cgi->redirect("/cgi-bin/koha/catalogue/ISBDdetail.pl?biblionumber=$biblionumber");
 596             } elsif  ($defaultview eq 'marc' && $views->{can_view_MARC}) {
 597                 print $cgi->redirect("/cgi-bin/koha/catalogue/MARCdetail.pl?biblionumber=$biblionumber");
 598             } elsif  ($defaultview eq 'labeled_marc' && $views->{can_view_labeledMARC}) {
 599                 print $cgi->redirect("/cgi-bin/koha/catalogue/labeledMARCdetail.pl?biblionumber=$biblionumber");
 600             } else {
 601                 print $cgi->redirect("/cgi-bin/koha/catalogue/detail.pl?biblionumber=$biblionumber");
 602             }
 603             exit;
 604         }
 605
 606         # set up parameters if user wishes to re-run the search
 607         # as a Z39.50 search
 608         $template->param (z3950_search_params => C4::Search::z3950_search_args($z3950par || $query_desc));
 609
 610         if ($hits) {
 611             $template->param(total => $hits);
 612             if ($limit_cgi) {
 613                 my $limit_cgi_not_availablity = $limit_cgi;
 614                 $limit_cgi_not_availablity =~ s/&limit=available//g;
 615                 $template->param(limit_cgi_not_availablity => $limit_cgi_not_availablity);
 616             }
 617             $template->param(limit_cgi => $limit_cgi);
 618             $template->param(query_cgi => $query_cgi);
 619             $template->param(query_desc => $query_desc);
 620             $template->param(limit_desc => $limit_desc);
 621             $template->param(offset     => $offset);
 622             $template->param(DisplayMultiPlaceHold => $DisplayMultiPlaceHold);
 623             if ($query_desc || $limit_desc) {
 624                 $template->param(searchdesc => 1);
 625             }
 626             $template->param(results_per_page =>  $results_per_page);
 627             # must define a value for size if not present in DB
 628             # in order to avoid problems generated by the default size value in TT
 629             foreach my $line (@newresults) {
 630                 if ( not exists $line->{'size'} ) { $line->{'size'} = "" }
 631                 # while we're checking each line, see if item is in the cart
 632                 if ( grep {$_ eq $line->{'biblionumber'}} @cart_list) {
 633                     $line->{'incart'} = 1;
 634                 }
 635             }
 636             $template->param(SEARCH_RESULTS => \@newresults);
 637             ## FIXME: add a global function for this, it's better than the current global one
 638             ## Build the page numbers on the bottom of the page
 639             my @page_numbers;
 640             my $max_result_window = $searcher->max_result_window;
 641             my $hits_to_paginate = ($max_result_window && $max_result_window < $hits) ? $max_result_window : $hits;
 642             $template->param( hits_to_paginate => $hits_to_paginate );
 643             # total number of pages there will be
 644             my $pages = ceil($hits_to_paginate / $results_per_page);
 645             my $last_page_offset = ( $pages -1 ) * $results_per_page;
 646             # default page number
 647             my $current_page_number = 1;
 648             $current_page_number = ($offset / $results_per_page + 1) if $offset;
 649             my $previous_page_offset;
 650             if ( $offset >= $results_per_page ) {
 651                 $previous_page_offset = $offset - $results_per_page;
 652             }
 653             my $next_page_offset = $offset + $results_per_page;
 654             # If we're within the first 10 pages, keep it simple
 655             #warn "current page:".$current_page_number;
 656             if ($current_page_number < 10) {
 657                 # just show the first 10 pages
 658                 # Loop through the pages
 659                 my $pages_to_show = 10;
 660                 $pages_to_show = $pages if $pages<10;
 661                 for (my $i=1; $i<=$pages_to_show;$i++) {
 662                     # the offset for this page
 663                     my $this_offset = (($i*$results_per_page)-$results_per_page);
 664                     # the page number for this page
 665                     my $this_page_number = $i;
 666                     # put it in the array
 667                     push @page_numbers,
 668                       { offset    => $this_offset,
 669                         pg        => $this_page_number,
 670                         # it should only be highlighted if it's the current page
 671                         highlight => $this_page_number == $current_page_number,
 672                         sort_by   => join ' ', @sort_by
 673                       };
 674
 675                 }
 676
 677             }
 678
 679             # now, show twenty pages, with the current one smack in the middle
 680             else {
 681                 for (my $i=$current_page_number; $i<=($current_page_number + 20 );$i++) {
 682                     my $this_offset = ((($i-9)*$results_per_page)-$results_per_page);
 683                     my $this_page_number = $i-9;
 684                     if ( $this_page_number <= $pages ) {
 685                         push @page_numbers,
 686                           { offset    => $this_offset,
 687                             pg        => $this_page_number,
 688                             highlight => $this_page_number == $current_page_number,
 689                             sort_by   => join ' ', @sort_by
 690                           };
 691                     }
 692                 }
 693             }
 694             # FIXME: no previous_page_offset when pages < 2
 695             $template->param(   PAGE_NUMBERS => \@page_numbers,
 696                                 last_page_offset => $last_page_offset,
 697                                 previous_page_offset => $previous_page_offset) unless $pages < 2;
 698             $template->param(   next_page_offset => $next_page_offset) unless $pages eq $current_page_number;
 699         }
 700
 701
 702         # no hits
 703         else {
 704             $template->param(searchdesc => 1,query_desc => $query_desc,limit_desc => $limit_desc);
 705         }
 706
 707     } # end of the if local
 708
 709     # asynchronously search the authority server
 710     elsif ($server =~/authorityserver/) { # this is the local authority server
 711         my @inner_sup_results_array;
 712         for my $sup_record ( @{$results_hashref->{$server}->{"RECORDS"}} ) {
 713             my $marc_record_object = C4::Search::new_record_from_zebra(
 714                 'authorityserver',
 715                 $sup_record
 716             );
 717             # warn "Authority Found: ".$marc_record_object->as_formatted();
 718             push @inner_sup_results_array, {
 719                 'title' => $marc_record_object->field(100)->subfield('a'),
 720                 'link' => "&amp;idx=an&amp;q=".$marc_record_object->field('001')->as_string(),
 721             };
 722         }
 723         push @sup_results_array, {  servername => $server,
 724                                     inner_sup_results_loop => \@inner_sup_results_array} if @inner_sup_results_array;
 725     }
 726     # FIXME: can add support for other targets as needed here
 727     $template->param(           outer_sup_results_loop => \@sup_results_array);
 728 } #/end of the for loop
 729 #$template->param(FEDERATED_RESULTS => \@results_array);
 730
 731 $template->{'VARS'}->{'searchid'} = $cgi->param('searchid');
 732
 733 my $gotonumber = $cgi->param('gotoNumber');
 734 if ( $gotonumber && ( $gotonumber eq 'last' || $gotonumber eq 'first' ) ) {
 735     $template->{'VARS'}->{'gotoNumber'} = $gotonumber;
 736 }
 737 $template->{'VARS'}->{'gotoPage'}   = 'detail.pl';
 738 my $gotopage = $cgi->param('gotoPage');
 739 $template->{'VARS'}->{'gotoPage'} = $gotopage
 740   if $gotopage && $gotopage =~ m/^(ISBD|labeledMARC|MARC|more)?detail.pl$/;
 741
 742 for my $facet ( @$facets ) {
 743     for my $entry ( @{ $facet->{facets} } ) {
 744         my $index = $entry->{type_link_value};
 745         my $value = $entry->{facet_link_value};
 746         $entry->{active} = grep { $_->{input_value} eq qq{$index:$value} } @limit_inputs;
 747     }
 748 }
 749
 750 $template->param(
 751             #classlist => $classlist,
 752             total => $total,
 753             opacfacets => 1,
 754             facets_loop => $facets,
 755             displayFacetCount=> C4::Context->preference('displayFacetCount')||0,
 756             scan => $scan,
 757             search_error => $error,
 758 );
 759
 760 if ($query_desc || $limit_desc) {
 761     $template->param(searchdesc => 1);
 762 }
 763
 764 # VI. BUILD THE TEMPLATE
 765
 766 my $some_private_shelves = Koha::Virtualshelves->get_some_shelves(
 767     {
 768         borrowernumber => $borrowernumber,
 769         add_allowed    => 1,
 770         category       => 1,
 771     }
 772 );
 773 my $some_public_shelves = Koha::Virtualshelves->get_some_shelves(
 774     {
 775         borrowernumber => $borrowernumber,
 776         add_allowed    => 1,
 777         category       => 2,
 778     }
 779 );
 780
 781
 782 $template->param(
 783     add_to_some_private_shelves => $some_private_shelves,
 784     add_to_some_public_shelves  => $some_public_shelves,
 785 );
 786
 787 output_html_with_http_headers $cgi, $cookie, $template->output;
 788
 789
 790 =head2 prepare_adv_search_types
 791
 792     my $type = C4::Context->preference("AdvancedSearchTypes") || "itemtypes";
 793     my @advanced_search_types = prepare_adv_search_types($type);
 794
 795 Different types can be searched for in the advanced search. This takes the
 796 system preference that defines these types and parses it into an arrayref for
 797 the template.
 798
 799 "itemtypes" is handled specially, as itemtypes aren't an authorised value.
 800 It also accounts for the "item-level_itypes" system preference.
 801
 802 =cut
 803
 804 sub prepare_adv_search_types {
 805     my ($types) = @_;
 806
 807     my @advanced_search_types = split( /\|/, $types );
 808
 809     # the index parameter is different for item-level itemtypes
 810     my $itype_or_itemtype =
 811       ( C4::Context->preference("item-level_itypes") ) ? 'itype' : 'itemtype';
 812     my $itemtypes = { map { $_->{itemtype} => $_ } @{ Koha::ItemTypes->search_with_localization->unblessed } };
 813
 814     my ( $cnt, @result );
 815     foreach my $advanced_srch_type (@advanced_search_types) {
 816         $advanced_srch_type =~ s/^\s*//;
 817         $advanced_srch_type =~ s/\s*$//;
 818         if ( $advanced_srch_type eq 'itemtypes' ) {
 819
 820        # itemtype is a special case, since it's not defined in authorized values
 821             my @itypesloop;
 822             foreach my $thisitemtype (
 823                 sort {
 824                     $itemtypes->{$a}->{'translated_description'}
 825                       cmp $itemtypes->{$b}->{'translated_description'}
 826                 } keys %$itemtypes
 827               )
 828             {
 829                 my %row = (
 830                     number      => $cnt++,
 831                     ccl         => "$itype_or_itemtype,phr",
 832                     code        => $thisitemtype,
 833                     description => $itemtypes->{$thisitemtype}->{'translated_description'},
 834                     imageurl    => getitemtypeimagelocation(
 835                         'intranet', $itemtypes->{$thisitemtype}->{'imageurl'}
 836                     ),
 837                 );
 838                 push @itypesloop, \%row;
 839             }
 840             my %search_code = (
 841                 advanced_search_type => $advanced_srch_type,
 842                 code_loop            => \@itypesloop
 843             );
 844             push @result, \%search_code;
 845         }
 846         else {
 847             # covers all the other cases: non-itemtype authorized values
 848             my $advsearchtypes = GetAuthorisedValues($advanced_srch_type);
 849             my @authvalueloop;
 850             for my $thisitemtype (@$advsearchtypes) {
 851                 my %row = (
 852                     number      => $cnt++,
 853                     ccl         => $advanced_srch_type,
 854                     code        => $thisitemtype->{authorised_value},
 855                     description => $thisitemtype->{'lib'},
 856                     imageurl    => getitemtypeimagelocation(
 857                         'intranet', $thisitemtype->{'imageurl'}
 858                     ),
 859                 );
 860                 push @authvalueloop, \%row;
 861             }
 862             my %search_code = (
 863                 advanced_search_type => $advanced_srch_type,
 864                 code_loop            => \@authvalueloop
 865             );
 866             push @result, \%search_code;
 867         }
 868     }
 869     return \@result;
 870 }