admin/smart-rules.pl

   1 #!/usr/bin/perl
   2 # Copyright 2000-2002 Katipo Communications
   3 # copyright 2010 BibLibre
   4 #
   5 # This file is part of Koha.
   6 #
   7 # Koha is free software; you can redistribute it and/or modify it
   8 # under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3 of the License, or
  10 # (at your option) any later version.
  11 #
  12 # Koha is distributed in the hope that it will be useful, but
  13 # WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  19
  20 use Modern::Perl;
  21 use CGI qw ( -utf8 );
  22 use C4::Context;
  23 use C4::Output;
  24 use C4::Auth;
  25 use C4::Koha;
  26 use C4::Debug;
  27 use Koha::DateUtils;
  28 use Koha::Database;
  29 use Koha::IssuingRule;
  30 use Koha::IssuingRules;
  31 use Koha::Logger;
  32 use Koha::RefundLostItemFeeRule;
  33 use Koha::RefundLostItemFeeRules;
  34 use Koha::Libraries;
  35 use Koha::CirculationRules;
  36 use Koha::Patron::Categories;
  37 use Koha::Caches;
  38 use Koha::Patrons;
  39
  40 my $input = CGI->new;
  41 my $dbh = C4::Context->dbh;
  42
  43 # my $flagsrequired;
  44 # $flagsrequired->{circulation}=1;
  45 my ($template, $loggedinuser, $cookie)
  46     = get_template_and_user({template_name => "admin/smart-rules.tt",
  47                             query => $input,
  48                             type => "intranet",
  49                             authnotrequired => 0,
  50                             flagsrequired => {parameters => 'manage_circ_rules'},
  51                             debug => 1,
  52                             });
  53
  54 my $type=$input->param('type');
  55
  56 my $branch = $input->param('branch');
  57 unless ( $branch ) {
  58     if ( C4::Context->preference('DefaultToLoggedInLibraryCircRules') ) {
  59         $branch = Koha::Libraries->search->count() == 1 ? undef : C4::Context::mybranch();
  60     }
  61     else {
  62         $branch = C4::Context::only_my_library() ? ( C4::Context::mybranch() || '*' ) : '*';
  63     }
  64 }
  65
  66 my $logged_in_patron = Koha::Patrons->find( $loggedinuser );
  67
  68 my $can_edit_from_any_library = $logged_in_patron->has_permission( {parameters => 'manage_circ_rules_from_any_libraries' } );
  69 $template->param( restricted_to_own_library => not $can_edit_from_any_library );
  70 $branch = C4::Context::mybranch() unless $can_edit_from_any_library;
  71
  72 $branch = '*' if $branch eq 'NO_LIBRARY_SET';
  73
  74 my $op = $input->param('op') || q{};
  75 my $language = C4::Languages::getlanguage();
  76
  77 my $cache = Koha::Caches->get_instance;
  78 $cache->clear_from_cache( Koha::IssuingRules::GUESSED_ITEMTYPES_KEY );
  79
  80 if ($op eq 'delete') {
  81     my $itemtype     = $input->param('itemtype');
  82     my $categorycode = $input->param('categorycode');
  83     $debug and warn "deleting $1 $2 $branch";
  84
  85     Koha::IssuingRules->find({
  86         branchcode   => $branch,
  87         categorycode => $categorycode,
  88         itemtype     => $itemtype
  89     })->delete;
  90
  91 }
  92 elsif ($op eq 'delete-branch-cat') {
  93     my $categorycode  = $input->param('categorycode');
  94     if ($branch eq "*") {
  95         if ($categorycode eq "*") {
  96              Koha::CirculationRules->set_rules(
  97                  {
  98                      categorycode => undef,
  99                      branchcode   => undef,
 100                      itemtype     => undef,
 101                      rules        => {
 102                          patron_maxissueqty             => undef,
 103                          patron_maxonsiteissueqty       => undef,
 104                          holdallowed             => undef,
 105                          hold_fulfillment_policy => undef,
 106                          returnbranch            => undef,
 107                          max_holds               => undef,
 108                      }
 109                  }
 110              );
 111          } else {
 112              Koha::CirculationRules->set_rules(
 113                  {
 114                      categorycode => $categorycode,
 115                      branchcode   => undef,
 116                      itemtype     => undef,
 117                      rules        => {
 118                          max_holds         => undef,
 119                          patron_maxissueqty       => undef,
 120                          patron_maxonsiteissueqty => undef,
 121                      }
 122                  }
 123              );
 124         }
 125     } elsif ($categorycode eq "*") {
 126         Koha::CirculationRules->set_rules(
 127             {
 128                 categorycode => undef,
 129                 branchcode   => $branch,
 130                 itemtype     => undef,
 131                 rules        => {
 132                     patron_maxissueqty             => undef,
 133                     patron_maxonsiteissueqty       => undef,
 134                     holdallowed             => undef,
 135                     hold_fulfillment_policy => undef,
 136                     returnbranch            => undef,
 137                     max_holds               => undef,
 138                 }
 139             }
 140         );
 141     } else {
 142         Koha::CirculationRules->set_rules(
 143             {
 144                 categorycode => $categorycode,
 145                 branchcode   => $branch,
 146                 itemtype     => undef,
 147                 rules        => {
 148                     max_holds         => undef,
 149                     patron_maxissueqty       => undef,
 150                     patron_maxonsiteissueqty => undef,
 151                 }
 152             }
 153         );
 154     }
 155 }
 156 elsif ($op eq 'delete-branch-item') {
 157     my $itemtype  = $input->param('itemtype');
 158     if ($branch eq "*") {
 159         if ($itemtype eq "*") {
 160             Koha::CirculationRules->set_rules(
 161                 {
 162                     categorycode => undef,
 163                     branchcode   => undef,
 164                     itemtype     => undef,
 165                     rules        => {
 166                         patron_maxissueqty             => undef,
 167                         patron_maxonsiteissueqty       => undef,
 168                         holdallowed             => undef,
 169                         hold_fulfillment_policy => undef,
 170                         returnbranch            => undef,
 171                     }
 172                 }
 173             );
 174         } else {
 175             Koha::CirculationRules->set_rules(
 176                 {
 177                     categorycode => undef,
 178                     branchcode   => undef,
 179                     itemtype     => $itemtype,
 180                     rules        => {
 181                         holdallowed             => undef,
 182                         hold_fulfillment_policy => undef,
 183                         returnbranch            => undef,
 184                     }
 185                 }
 186             );
 187         }
 188     } elsif ($itemtype eq "*") {
 189         Koha::CirculationRules->set_rules(
 190             {
 191                 categorycode => undef,
 192                 branchcode   => $branch,
 193                 itemtype     => undef,
 194                 rules        => {
 195                     maxissueqty             => undef,
 196                     maxonsiteissueqty       => undef,
 197                     holdallowed             => undef,
 198                     hold_fulfillment_policy => undef,
 199                     returnbranch            => undef,
 200                 }
 201             }
 202         );
 203     } else {
 204         Koha::CirculationRules->set_rules(
 205             {
 206                 categorycode => undef,
 207                 branchcode   => $branch,
 208                 itemtype     => $itemtype,
 209                 rules        => {
 210                     holdallowed             => undef,
 211                     hold_fulfillment_policy => undef,
 212                     returnbranch            => undef,
 213                 }
 214             }
 215         );
 216     }
 217 }
 218 # save the values entered
 219 elsif ($op eq 'add') {
 220     my $br = $branch; # branch
 221     my $bor  = $input->param('categorycode'); # borrower category
 222     my $itemtype  = $input->param('itemtype');     # item type
 223     my $fine = $input->param('fine');
 224     my $finedays     = $input->param('finedays');
 225     my $maxsuspensiondays = $input->param('maxsuspensiondays');
 226     $maxsuspensiondays = undef if $maxsuspensiondays eq q||;
 227     my $suspension_chargeperiod = $input->param('suspension_chargeperiod') || 1;
 228     my $firstremind  = $input->param('firstremind');
 229     my $chargeperiod = $input->param('chargeperiod');
 230     my $chargeperiod_charge_at = $input->param('chargeperiod_charge_at');
 231     my $maxissueqty  = $input->param('maxissueqty');
 232     my $maxonsiteissueqty  = $input->param('maxonsiteissueqty');
 233     my $renewalsallowed  = $input->param('renewalsallowed');
 234     my $renewalperiod    = $input->param('renewalperiod');
 235     my $norenewalbefore  = $input->param('norenewalbefore');
 236     $norenewalbefore = undef if $norenewalbefore =~ /^\s*$/;
 237     my $auto_renew = $input->param('auto_renew') eq 'yes' ? 1 : 0;
 238     my $no_auto_renewal_after = $input->param('no_auto_renewal_after');
 239     $no_auto_renewal_after = undef if $no_auto_renewal_after =~ /^\s*$/;
 240     my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') || undef;
 241     $no_auto_renewal_after_hard_limit = eval { dt_from_string( $input->param('no_auto_renewal_after_hard_limit') ) } if ( $no_auto_renewal_after_hard_limit );
 242     $no_auto_renewal_after_hard_limit = output_pref( { dt => $no_auto_renewal_after_hard_limit, dateonly => 1, dateformat => 'iso' } ) if ( $no_auto_renewal_after_hard_limit );
 243     my $reservesallowed  = $input->param('reservesallowed');
 244     my $holds_per_record = $input->param('holds_per_record');
 245     my $holds_per_day    = $input->param('holds_per_day');
 246     $holds_per_day =~ s/\s//g;
 247     $holds_per_day = undef if $holds_per_day !~ /^\d+/;
 248     my $onshelfholds     = $input->param('onshelfholds') || 0;
 249     $maxissueqty =~ s/\s//g;
 250     $maxissueqty = '' if $maxissueqty !~ /^\d+/;
 251     $maxonsiteissueqty =~ s/\s//g;
 252     $maxonsiteissueqty = '' if $maxonsiteissueqty !~ /^\d+/;
 253     my $issuelength  = $input->param('issuelength');
 254     $issuelength = $issuelength eq q{} ? undef : $issuelength;
 255     my $lengthunit  = $input->param('lengthunit');
 256     my $hardduedate = $input->param('hardduedate') || undef;
 257     $hardduedate = eval { dt_from_string( $input->param('hardduedate') ) } if ( $hardduedate );
 258     $hardduedate = output_pref( { dt => $hardduedate, dateonly => 1, dateformat => 'iso' } ) if ( $hardduedate );
 259     my $hardduedatecompare = $input->param('hardduedatecompare');
 260     my $rentaldiscount = $input->param('rentaldiscount');
 261     my $opacitemholds = $input->param('opacitemholds') || 0;
 262     my $article_requests = $input->param('article_requests') || 'no';
 263     my $overduefinescap = $input->param('overduefinescap') || undef;
 264     my $cap_fine_to_replacement_price = $input->param('cap_fine_to_replacement_price') eq 'on';
 265     my $note = $input->param('note');
 266     $debug and warn "Adding $br, $bor, $itemtype, $fine, $maxissueqty, $maxonsiteissueqty, $cap_fine_to_replacement_price";
 267
 268     my $params = {
 269         branchcode                    => $br,
 270         categorycode                  => $bor,
 271         itemtype                      => $itemtype,
 272         fine                          => $fine,
 273         finedays                      => $finedays,
 274         maxsuspensiondays             => $maxsuspensiondays,
 275         suspension_chargeperiod       => $suspension_chargeperiod,
 276         firstremind                   => $firstremind,
 277         chargeperiod                  => $chargeperiod,
 278         chargeperiod_charge_at        => $chargeperiod_charge_at,
 279         renewalsallowed               => $renewalsallowed,
 280         renewalperiod                 => $renewalperiod,
 281         norenewalbefore               => $norenewalbefore,
 282         auto_renew                    => $auto_renew,
 283         no_auto_renewal_after         => $no_auto_renewal_after,
 284         no_auto_renewal_after_hard_limit => $no_auto_renewal_after_hard_limit,
 285         reservesallowed               => $reservesallowed,
 286         holds_per_record              => $holds_per_record,
 287         holds_per_day                 => $holds_per_day,
 288         issuelength                   => $issuelength,
 289         lengthunit                    => $lengthunit,
 290         hardduedate                   => $hardduedate,
 291         hardduedatecompare            => $hardduedatecompare,
 292         rentaldiscount                => $rentaldiscount,
 293         onshelfholds                  => $onshelfholds,
 294         opacitemholds                 => $opacitemholds,
 295         overduefinescap               => $overduefinescap,
 296         cap_fine_to_replacement_price => $cap_fine_to_replacement_price,
 297         article_requests              => $article_requests,
 298         note                          => $note,
 299     };
 300
 301     my $issuingrule = Koha::IssuingRules->find({categorycode => $bor, itemtype => $itemtype, branchcode => $br});
 302     if ($issuingrule) {
 303         $issuingrule->set($params)->store();
 304     } else {
 305         Koha::IssuingRule->new()->set($params)->store();
 306     }
 307     Koha::CirculationRules->set_rules(
 308         {
 309             categorycode => $bor,
 310             itemtype     => $itemtype,
 311             branchcode   => $br,
 312             rules        => {
 313                 maxissueqty       => $maxissueqty,
 314                 maxonsiteissueqty => $maxonsiteissueqty,
 315             }
 316         }
 317     );
 318
 319 }
 320 elsif ($op eq "set-branch-defaults") {
 321     my $categorycode  = $input->param('categorycode');
 322     my $patron_maxissueqty   = $input->param('patron_maxissueqty');
 323     my $patron_maxonsiteissueqty = $input->param('patron_maxonsiteissueqty');
 324     my $holdallowed   = $input->param('holdallowed');
 325     my $hold_fulfillment_policy = $input->param('hold_fulfillment_policy');
 326     my $returnbranch  = $input->param('returnbranch');
 327     my $max_holds = $input->param('max_holds');
 328     $patron_maxissueqty =~ s/\s//g;
 329     $patron_maxissueqty = '' if $patron_maxissueqty !~ /^\d+/;
 330     $patron_maxonsiteissueqty =~ s/\s//g;
 331     $patron_maxonsiteissueqty = '' if $patron_maxonsiteissueqty !~ /^\d+/;
 332     $holdallowed =~ s/\s//g;
 333     $holdallowed = undef if $holdallowed !~ /^\d+/;
 334     $max_holds =~ s/\s//g;
 335     $max_holds = '' if $max_holds !~ /^\d+/;
 336
 337     if ($branch eq "*") {
 338         Koha::CirculationRules->set_rules(
 339             {
 340                 categorycode => undef,
 341                 itemtype     => undef,
 342                 branchcode   => undef,
 343                 rules        => {
 344                     patron_maxissueqty       => $patron_maxissueqty,
 345                     patron_maxonsiteissueqty => $patron_maxonsiteissueqty,
 346                     holdallowed              => $holdallowed,
 347                     hold_fulfillment_policy  => $hold_fulfillment_policy,
 348                     returnbranch             => $returnbranch,
 349                 }
 350             }
 351         );
 352     } else {
 353         Koha::CirculationRules->set_rules(
 354             {
 355                 categorycode => undef,
 356                 itemtype     => undef,
 357                 branchcode   => $branch,
 358                 rules        => {
 359                     patron_maxissueqty       => $patron_maxissueqty,
 360                     patron_maxonsiteissueqty => $patron_maxonsiteissueqty,
 361                     holdallowed              => $holdallowed,
 362                     hold_fulfillment_policy  => $hold_fulfillment_policy,
 363                     returnbranch             => $returnbranch,
 364                 }
 365             }
 366         );
 367     }
 368     Koha::CirculationRules->set_rule(
 369         {
 370             branchcode   => $branch,
 371             categorycode => undef,
 372             itemtype     => undef,
 373             rule_name    => 'max_holds',
 374             rule_value   => $max_holds,
 375         }
 376     );
 377 }
 378 elsif ($op eq "add-branch-cat") {
 379     my $categorycode  = $input->param('categorycode');
 380     my $patron_maxissueqty   = $input->param('patron_maxissueqty');
 381     my $patron_maxonsiteissueqty = $input->param('patron_maxonsiteissueqty');
 382     my $max_holds = $input->param('max_holds');
 383     $patron_maxissueqty =~ s/\s//g;
 384     $patron_maxissueqty = '' if $patron_maxissueqty !~ /^\d+/;
 385     $patron_maxonsiteissueqty =~ s/\s//g;
 386     $patron_maxonsiteissueqty = '' if $patron_maxonsiteissueqty !~ /^\d+/;
 387     $max_holds =~ s/\s//g;
 388     $max_holds = undef if $max_holds !~ /^\d+/;
 389
 390     if ($branch eq "*") {
 391         if ($categorycode eq "*") {
 392             Koha::CirculationRules->set_rules(
 393                 {
 394                     categorycode => undef,
 395                     itemtype     => undef,
 396                     branchcode   => undef,
 397                     rules        => {
 398                         max_holds         => $max_holds,
 399                         patron_maxissueqty       => $patron_maxissueqty,
 400                         patron_maxonsiteissueqty => $patron_maxonsiteissueqty,
 401                     }
 402                 }
 403             );
 404         } else {
 405             Koha::CirculationRules->set_rules(
 406                 {
 407                     branchcode   => undef,
 408                     categorycode => $categorycode,
 409                     itemtype     => undef,
 410                     rules        => {
 411                         max_holds         => $max_holds,
 412                         patron_maxissueqty       => $patron_maxissueqty,
 413                         patron_maxonsiteissueqty => $patron_maxonsiteissueqty,
 414                     }
 415                 }
 416             );
 417         }
 418     } elsif ($categorycode eq "*") {
 419         Koha::CirculationRules->set_rules(
 420             {
 421                 categorycode => undef,
 422                 itemtype     => undef,
 423                 branchcode   => $branch,
 424                 rules        => {
 425                     max_holds         => $max_holds,
 426                     patron_maxissueqty       => $patron_maxissueqty,
 427                     patron_maxonsiteissueqty => $patron_maxonsiteissueqty,
 428                 }
 429             }
 430         );
 431     } else {
 432         Koha::CirculationRules->set_rules(
 433             {
 434                 categorycode => $categorycode,
 435                 itemtype     => undef,
 436                 branchcode   => $branch,
 437                 rules        => {
 438                     max_holds         => $max_holds,
 439                     patron_maxissueqty       => $patron_maxissueqty,
 440                     patron_maxonsiteissueqty => $patron_maxonsiteissueqty,
 441                 }
 442             }
 443         );
 444     }
 445 }
 446 elsif ($op eq "add-branch-item") {
 447     my $itemtype                = $input->param('itemtype');
 448     my $holdallowed             = $input->param('holdallowed');
 449     my $hold_fulfillment_policy = $input->param('hold_fulfillment_policy');
 450     my $returnbranch            = $input->param('returnbranch');
 451
 452     $holdallowed =~ s/\s//g;
 453     $holdallowed = undef if $holdallowed !~ /^\d+/;
 454
 455     if ($branch eq "*") {
 456         if ($itemtype eq "*") {
 457             Koha::CirculationRules->set_rules(
 458                 {
 459                     categorycode => undef,
 460                     itemtype     => undef,
 461                     branchcode   => undef,
 462                     rules        => {
 463                         holdallowed             => $holdallowed,
 464                         hold_fulfillment_policy => $hold_fulfillment_policy,
 465                         returnbranch            => $returnbranch,
 466                     }
 467                 }
 468             );
 469         } else {
 470             Koha::CirculationRules->set_rules(
 471                 {
 472                     categorycode => undef,
 473                     itemtype     => $itemtype,
 474                     branchcode   => undef,
 475                     rules        => {
 476                         holdallowed             => $holdallowed,
 477                         hold_fulfillment_policy => $hold_fulfillment_policy,
 478                         returnbranch            => $returnbranch,
 479                     }
 480                 }
 481             );
 482         }
 483     } elsif ($itemtype eq "*") {
 484             Koha::CirculationRules->set_rules(
 485                 {
 486                     categorycode => undef,
 487                     itemtype     => undef,
 488                     branchcode   => $branch,
 489                     rules        => {
 490                         holdallowed             => $holdallowed,
 491                         hold_fulfillment_policy => $hold_fulfillment_policy,
 492                         returnbranch            => $returnbranch,
 493                     }
 494                 }
 495             );
 496     } else {
 497         Koha::CirculationRules->set_rules(
 498             {
 499                 categorycode => undef,
 500                 itemtype     => $itemtype,
 501                 branchcode   => $branch,
 502                 rules        => {
 503                     holdallowed             => $holdallowed,
 504                     hold_fulfillment_policy => $hold_fulfillment_policy,
 505                     returnbranch            => $returnbranch,
 506                 }
 507             }
 508         );
 509     }
 510 }
 511 elsif ( $op eq 'mod-refund-lost-item-fee-rule' ) {
 512
 513     my $refund = $input->param('refund');
 514
 515     if ( $refund eq '*' ) {
 516         if ( $branch ne '*' ) {
 517             # only do something for $refund eq '*' if branch-specific
 518             eval {
 519                 # Delete it so it picks the default
 520                 Koha::RefundLostItemFeeRules->find({
 521                     branchcode => $branch
 522                 })->delete;
 523             };
 524         }
 525     } else {
 526         my $refundRule =
 527                 Koha::RefundLostItemFeeRules->find({
 528                     branchcode => $branch
 529                 }) // Koha::RefundLostItemFeeRule->new;
 530         $refundRule->set({
 531             branchcode => $branch,
 532                 refund => $refund
 533         })->store;
 534     }
 535 }
 536
 537 my $refundLostItemFeeRule = Koha::RefundLostItemFeeRules->find({ branchcode => $branch });
 538 $template->param(
 539     refundLostItemFeeRule => $refundLostItemFeeRule,
 540     defaultRefundRule     => Koha::RefundLostItemFeeRules->_default_rule
 541 );
 542
 543 my $patron_categories = Koha::Patron::Categories->search({}, { order_by => ['description'] });
 544
 545 my @row_loop;
 546 my $itemtypes = Koha::ItemTypes->search_with_localization;
 547
 548 my $sth2 = $dbh->prepare("
 549     SELECT  issuingrules.*,
 550             itemtypes.description AS humanitemtype,
 551             categories.description AS humancategorycode,
 552             COALESCE( localization.translation, itemtypes.description ) AS translated_description
 553     FROM issuingrules
 554     LEFT JOIN itemtypes
 555         ON (itemtypes.itemtype = issuingrules.itemtype)
 556     LEFT JOIN categories
 557         ON (categories.categorycode = issuingrules.categorycode)
 558     LEFT JOIN localization ON issuingrules.itemtype = localization.code
 559         AND localization.entity = 'itemtypes'
 560         AND localization.lang = ?
 561     WHERE issuingrules.branchcode = ?
 562 ");
 563 $sth2->execute($language, $branch);
 564
 565 while (my $row = $sth2->fetchrow_hashref) {
 566     $row->{'current_branch'} ||= $row->{'branchcode'};
 567     $row->{humanitemtype} ||= $row->{itemtype};
 568     $row->{default_translated_description} = 1 if $row->{humanitemtype} eq '*';
 569     $row->{'humancategorycode'} ||= $row->{'categorycode'};
 570     $row->{'default_humancategorycode'} = 1 if $row->{'humancategorycode'} eq '*';
 571     $row->{'fine'} = sprintf('%.2f', $row->{'fine'});
 572     if ($row->{'hardduedate'} && $row->{'hardduedate'} ne '0000-00-00') {
 573        my $harddue_dt = eval { dt_from_string( $row->{'hardduedate'} ) };
 574        $row->{'hardduedate'} = eval { output_pref( { dt => $harddue_dt, dateonly => 1 } ) } if ( $harddue_dt );
 575        $row->{'hardduedatebefore'} = 1 if ($row->{'hardduedatecompare'} == -1);
 576        $row->{'hardduedateexact'} = 1 if ($row->{'hardduedatecompare'} ==  0);
 577        $row->{'hardduedateafter'} = 1 if ($row->{'hardduedatecompare'} ==  1);
 578     } else {
 579        $row->{'hardduedate'} = 0;
 580     }
 581     if ($row->{no_auto_renewal_after_hard_limit}) {
 582        my $dt = eval { dt_from_string( $row->{no_auto_renewal_after_hard_limit} ) };
 583        $row->{no_auto_renewal_after_hard_limit} = eval { output_pref( { dt => $dt, dateonly => 1 } ) } if $dt;
 584     }
 585
 586     push @row_loop, $row;
 587 }
 588
 589 my @sorted_row_loop = sort by_category_and_itemtype @row_loop;
 590
 591 $template->param(show_branch_cat_rule_form => 1);
 592
 593 $template->param(
 594     patron_categories => $patron_categories,
 595                         itemtypeloop => $itemtypes,
 596                         rules => \@sorted_row_loop,
 597                         humanbranch => ($branch ne '*' ? $branch : ''),
 598                         current_branch => $branch,
 599                         definedbranch => scalar(@sorted_row_loop)>0
 600                         );
 601 output_html_with_http_headers $input, $cookie, $template->output;
 602
 603 exit 0;
 604
 605 # sort by patron category, then item type, putting
 606 # default entries at the bottom
 607 sub by_category_and_itemtype {
 608     unless (by_category($a, $b)) {
 609         return by_itemtype($a, $b);
 610     }
 611 }
 612
 613 sub by_category {
 614     my ($a, $b) = @_;
 615     if ($a->{'default_humancategorycode'}) {
 616         return ($b->{'default_humancategorycode'} ? 0 : 1);
 617     } elsif ($b->{'default_humancategorycode'}) {
 618         return -1;
 619     } else {
 620         return $a->{'humancategorycode'} cmp $b->{'humancategorycode'};
 621     }
 622 }
 623
 624 sub by_itemtype {
 625     my ($a, $b) = @_;
 626     if ($a->{default_translated_description}) {
 627         return ($b->{'default_translated_description'} ? 0 : 1);
 628     } elsif ($b->{'default_translated_description'}) {
 629         return -1;
 630     } else {
 631         return lc $a->{'translated_description'} cmp lc $b->{'translated_description'};
 632     }
 633 }