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