X-Git-Url: http://koha-dev.rot13.org:8081/gitweb/?a=blobdiff_plain;f=admin%2Fsmart-rules.pl;h=b7f2ae643ec4f7b4bdfa0fd523525808fd6b8622;hb=b8f1b0e73d8a0b9562361b983a38d9eafcf202eb;hp=456e7384ca05682191bec713aea7a5c22dca5cb1;hpb=ef25c3665bcde5278512225297100f26d3dc531a;p=koha-ffzg.git diff --git a/admin/smart-rules.pl b/admin/smart-rules.pl index 456e7384ca..b7f2ae643e 100755 --- a/admin/smart-rules.pl +++ b/admin/smart-rules.pl @@ -4,29 +4,33 @@ # # This file is part of Koha. # -# Koha is free software; you can redistribute it and/or modify it under the -# terms of the GNU General Public License as published by the Free Software -# Foundation; either version 2 of the License, or (at your option) any later -# version. +# Koha is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. # -# Koha is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR -# A PARTICULAR PURPOSE. See the GNU General Public License for more details. +# Koha is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. # -# You should have received a copy of the GNU General Public License along -# with Koha; if not, write to the Free Software Foundation, Inc., -# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +# You should have received a copy of the GNU General Public License +# along with Koha; if not, see . -use strict; -use warnings; -use CGI; +use Modern::Perl; +use CGI qw ( -utf8 ); use C4::Context; -use C4::Output; -use C4::Auth; -use C4::Koha; -use C4::Debug; -use C4::Branch; # GetBranches -use C4::Dates qw/format_date format_date_in_iso/; +use C4::Output qw( output_html_with_http_headers ); +use C4::Auth qw( get_template_and_user ); +use Koha::Exception; +use Koha::DateUtils qw( dt_from_string output_pref ); +use Koha::Database; +use Koha::Logger; +use Koha::Libraries; +use Koha::CirculationRules; +use Koha::Patron::Categories; +use Koha::Caches; +use Koha::Patrons; my $input = CGI->new; my $dbh = C4::Context->dbh; @@ -34,476 +38,662 @@ my $dbh = C4::Context->dbh; # my $flagsrequired; # $flagsrequired->{circulation}=1; my ($template, $loggedinuser, $cookie) - = get_template_and_user({template_name => "admin/smart-rules.tmpl", + = get_template_and_user({template_name => "admin/smart-rules.tt", query => $input, type => "intranet", - authnotrequired => 0, flagsrequired => {parameters => 'manage_circ_rules'}, - debug => 1, }); my $type=$input->param('type'); -my $branch = $input->param('branch') || ( C4::Branch::onlymine() ? ( C4::Branch::mybranch() || '*' ) : '*' ); + +my $branch = $input->param('branch'); +unless ( $branch ) { + if ( C4::Context->preference('DefaultToLoggedInLibraryCircRules') ) { + $branch = Koha::Libraries->search->count() == 1 ? undef : C4::Context::mybranch(); + } + else { + $branch = C4::Context::only_my_library() ? ( C4::Context::mybranch() || '*' ) : '*'; + } +} + +my $logged_in_patron = Koha::Patrons->find( $loggedinuser ); + +my $can_edit_from_any_library = $logged_in_patron->has_permission( {parameters => 'manage_circ_rules_from_any_libraries' } ); +$template->param( restricted_to_own_library => not $can_edit_from_any_library ); +$branch = C4::Context::mybranch() unless $can_edit_from_any_library; + my $op = $input->param('op') || q{}; +my $language = C4::Languages::getlanguage(); + +my $cache = Koha::Caches->get_instance; +$cache->clear_from_cache( Koha::CirculationRules::GUESSED_ITEMTYPES_KEY ); if ($op eq 'delete') { my $itemtype = $input->param('itemtype'); my $categorycode = $input->param('categorycode'); - $debug and warn "deleting $1 $2 $branch"; - my $sth_Idelete = $dbh->prepare("delete from issuingrules where branchcode=? and categorycode=? and itemtype=?"); - $sth_Idelete->execute($branch, $categorycode, $itemtype); + Koha::CirculationRules->set_rules( + { + categorycode => $categorycode eq '*' ? undef : $categorycode, + branchcode => $branch eq '*' ? undef : $branch, + itemtype => $itemtype eq '*' ? undef : $itemtype, + rules => { + maxissueqty => undef, + maxonsiteissueqty => undef, + rentaldiscount => undef, + fine => undef, + finedays => undef, + maxsuspensiondays => undef, + suspension_chargeperiod => undef, + firstremind => undef, + chargeperiod => undef, + chargeperiod_charge_at => undef, + issuelength => undef, + daysmode => undef, + lengthunit => undef, + hardduedate => undef, + hardduedatecompare => undef, + renewalsallowed => undef, + unseen_renewals_allowed => undef, + renewalperiod => undef, + norenewalbefore => undef, + auto_renew => undef, + no_auto_renewal_after => undef, + no_auto_renewal_after_hard_limit => undef, + reservesallowed => undef, + holds_per_record => undef, + holds_per_day => undef, + onshelfholds => undef, + opacitemholds => undef, + overduefinescap => undef, + cap_fine_to_replacement_price => undef, + article_requests => undef, + note => undef, + recalls_allowed => undef, + recalls_per_record => undef, + on_shelf_recalls => undef, + recall_due_date_interval => undef, + recall_overdue_fine => undef, + recall_shelf_time => undef, + } + } + ); } elsif ($op eq 'delete-branch-cat') { my $categorycode = $input->param('categorycode'); if ($branch eq "*") { if ($categorycode eq "*") { - my $sth_delete = $dbh->prepare("DELETE FROM default_circ_rules"); - $sth_delete->execute(); + Koha::CirculationRules->set_rules( + { + branchcode => undef, + categorycode => undef, + rules => { + max_holds => undef, + patron_maxissueqty => undef, + patron_maxonsiteissueqty => undef, + } + } + ); + Koha::CirculationRules->set_rules( + { + branchcode => undef, + itemtype => undef, + rules => { + holdallowed => undef, + hold_fulfillment_policy => undef, + returnbranch => undef, + } + } + ); } else { - my $sth_delete = $dbh->prepare("DELETE FROM default_borrower_circ_rules - WHERE categorycode = ?"); - $sth_delete->execute($categorycode); + Koha::CirculationRules->set_rules( + { + categorycode => $categorycode, + branchcode => undef, + rules => { + max_holds => undef, + patron_maxissueqty => undef, + patron_maxonsiteissueqty => undef, + } + } + ); } } elsif ($categorycode eq "*") { - my $sth_delete = $dbh->prepare("DELETE FROM default_branch_circ_rules - WHERE branchcode = ?"); - $sth_delete->execute($branch); + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + categorycode => undef, + rules => { + max_holds => undef, + patron_maxissueqty => undef, + patron_maxonsiteissueqty => undef, + } + } + ); + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + itemtype => undef, + rules => { + holdallowed => undef, + hold_fulfillment_policy => undef, + returnbranch => undef, + } + } + ); } else { - my $sth_delete = $dbh->prepare("DELETE FROM branch_borrower_circ_rules - WHERE branchcode = ? - AND categorycode = ?"); - $sth_delete->execute($branch, $categorycode); + Koha::CirculationRules->set_rules( + { + categorycode => $categorycode, + branchcode => $branch, + rules => { + max_holds => undef, + patron_maxissueqty => undef, + patron_maxonsiteissueqty => undef, + } + } + ); } } elsif ($op eq 'delete-branch-item') { my $itemtype = $input->param('itemtype'); if ($branch eq "*") { if ($itemtype eq "*") { - my $sth_delete = $dbh->prepare("DELETE FROM default_circ_rules"); - $sth_delete->execute(); + Koha::CirculationRules->set_rules( + { + branchcode => undef, + itemtype => undef, + rules => { + holdallowed => undef, + hold_fulfillment_policy => undef, + returnbranch => undef, + } + } + ); } else { - my $sth_delete = $dbh->prepare("DELETE FROM default_branch_item_rules - WHERE itemtype = ?"); - $sth_delete->execute($itemtype); + Koha::CirculationRules->set_rules( + { + branchcode => undef, + itemtype => $itemtype, + rules => { + holdallowed => undef, + hold_fulfillment_policy => undef, + returnbranch => undef, + } + } + ); } } elsif ($itemtype eq "*") { - my $sth_delete = $dbh->prepare("DELETE FROM default_branch_circ_rules - WHERE branchcode = ?"); - $sth_delete->execute($branch); + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + itemtype => undef, + rules => { + holdallowed => undef, + hold_fulfillment_policy => undef, + returnbranch => undef, + } + } + ); } else { - my $sth_delete = $dbh->prepare("DELETE FROM branch_item_rules - WHERE branchcode = ? - AND itemtype = ?"); - $sth_delete->execute($branch, $itemtype); + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + itemtype => $itemtype, + rules => { + holdallowed => undef, + hold_fulfillment_policy => undef, + returnbranch => undef, + } + } + ); } } # save the values entered elsif ($op eq 'add') { - my $sth_search = $dbh->prepare('SELECT COUNT(*) AS total FROM issuingrules WHERE branchcode=? AND categorycode=? AND itemtype=?'); - my $sth_insert = $dbh->prepare('INSERT INTO issuingrules (branchcode, categorycode, itemtype, maxissueqty, renewalsallowed, renewalperiod, norenewalbefore, reservesallowed, issuelength, lengthunit, hardduedate, hardduedatecompare, fine, finedays, firstremind, chargeperiod,rentaldiscount, overduefinescap) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)'); - my $sth_update=$dbh->prepare("UPDATE issuingrules SET fine=?, finedays=?, firstremind=?, chargeperiod=?, maxissueqty=?, renewalsallowed=?, renewalperiod=?, norenewalbefore=?, reservesallowed=?, issuelength=?, lengthunit = ?, hardduedate=?, hardduedatecompare=?, rentaldiscount=?, overduefinescap=? WHERE branchcode=? AND categorycode=? AND itemtype=?"); - my $br = $branch; # branch my $bor = $input->param('categorycode'); # borrower category - my $cat = $input->param('itemtype'); # item type + my $itemtype = $input->param('itemtype'); # item type my $fine = $input->param('fine'); my $finedays = $input->param('finedays'); + my $maxsuspensiondays = $input->param('maxsuspensiondays') || ''; + my $suspension_chargeperiod = $input->param('suspension_chargeperiod') || 1; my $firstremind = $input->param('firstremind'); my $chargeperiod = $input->param('chargeperiod'); - my $maxissueqty = $input->param('maxissueqty'); + my $chargeperiod_charge_at = $input->param('chargeperiod_charge_at'); + my $maxissueqty = strip_non_numeric( scalar $input->param('maxissueqty') ); + my $maxonsiteissueqty = strip_non_numeric( scalar $input->param('maxonsiteissueqty') ); my $renewalsallowed = $input->param('renewalsallowed'); + my $unseen_renewals_allowed = $input->param('unseen_renewals_allowed'); my $renewalperiod = $input->param('renewalperiod'); my $norenewalbefore = $input->param('norenewalbefore'); - $norenewalbefore = undef if $norenewalbefore eq '0' or $norenewalbefore =~ /^\s*$/; - my $reservesallowed = $input->param('reservesallowed'); - $maxissueqty =~ s/\s//g; - $maxissueqty = undef if $maxissueqty !~ /^\d+/; + $norenewalbefore = '' if $norenewalbefore =~ /^\s*$/; + my $auto_renew = $input->param('auto_renew') eq 'yes' ? 1 : 0; + my $no_auto_renewal_after = $input->param('no_auto_renewal_after'); + $no_auto_renewal_after = '' if $no_auto_renewal_after =~ /^\s*$/; + my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') || ''; + $no_auto_renewal_after_hard_limit = eval { dt_from_string( scalar $no_auto_renewal_after_hard_limit ) } if ( $no_auto_renewal_after_hard_limit ); + $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 ); + my $reservesallowed = strip_non_numeric( scalar $input->param('reservesallowed') ); + my $holds_per_record = strip_non_numeric( scalar $input->param('holds_per_record') ); + my $holds_per_day = strip_non_numeric( scalar $input->param('holds_per_day') ); + my $onshelfholds = $input->param('onshelfholds') || 0; my $issuelength = $input->param('issuelength'); + $issuelength = $issuelength eq q{} ? undef : $issuelength; + my $daysmode = $input->param('daysmode'); my $lengthunit = $input->param('lengthunit'); - my $hardduedate = $input->param('hardduedate'); - $hardduedate = format_date_in_iso($hardduedate); + my $hardduedate = $input->param('hardduedate') || undef; + $hardduedate = eval { dt_from_string( scalar $hardduedate ) } if ( $hardduedate ); + $hardduedate = output_pref( { dt => $hardduedate, dateonly => 1, dateformat => 'iso' } ) if ( $hardduedate ); my $hardduedatecompare = $input->param('hardduedatecompare'); my $rentaldiscount = $input->param('rentaldiscount'); - my $overduefinescap = $input->param('overduefinescap') || undef; - $debug and warn "Adding $br, $bor, $cat, $fine, $maxissueqty"; + my $opacitemholds = $input->param('opacitemholds') || 0; + my $article_requests = $input->param('article_requests') || 'no'; + my $overduefinescap = $input->param('overduefinescap') || ''; + my $cap_fine_to_replacement_price = ($input->param('cap_fine_to_replacement_price') || '') eq 'on'; + my $note = $input->param('note'); + my $decreaseloanholds = $input->param('decreaseloanholds') || undef; + my $recalls_allowed = $input->param('recalls_allowed'); + my $recalls_per_record = $input->param('recalls_per_record'); + my $on_shelf_recalls = $input->param('on_shelf_recalls'); + my $recall_due_date_interval = $input->param('recall_due_date_interval'); + my $recall_overdue_fine = $input->param('recall_overdue_fine'); + my $recall_shelf_time = $input->param('recall_shelf_time'); + + my $rules = { + maxissueqty => $maxissueqty, + maxonsiteissueqty => $maxonsiteissueqty, + rentaldiscount => $rentaldiscount, + fine => $fine, + finedays => $finedays, + maxsuspensiondays => $maxsuspensiondays, + suspension_chargeperiod => $suspension_chargeperiod, + firstremind => $firstremind, + chargeperiod => $chargeperiod, + chargeperiod_charge_at => $chargeperiod_charge_at, + issuelength => $issuelength, + daysmode => $daysmode, + lengthunit => $lengthunit, + hardduedate => $hardduedate, + hardduedatecompare => $hardduedatecompare, + renewalsallowed => $renewalsallowed, + unseen_renewals_allowed => $unseen_renewals_allowed, + renewalperiod => $renewalperiod, + norenewalbefore => $norenewalbefore, + auto_renew => $auto_renew, + no_auto_renewal_after => $no_auto_renewal_after, + no_auto_renewal_after_hard_limit => $no_auto_renewal_after_hard_limit, + reservesallowed => $reservesallowed, + holds_per_record => $holds_per_record, + holds_per_day => $holds_per_day, + onshelfholds => $onshelfholds, + opacitemholds => $opacitemholds, + overduefinescap => $overduefinescap, + cap_fine_to_replacement_price => $cap_fine_to_replacement_price, + article_requests => $article_requests, + note => $note, + decreaseloanholds => $decreaseloanholds, + recalls_allowed => $recalls_allowed, + recalls_per_record => $recalls_per_record, + on_shelf_recalls => $on_shelf_recalls, + recall_due_date_interval => $recall_due_date_interval, + recall_overdue_fine => $recall_overdue_fine, + recall_shelf_time => $recall_shelf_time, + }; - $sth_search->execute($br,$bor,$cat); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($fine, $finedays,$firstremind, $chargeperiod, $maxissueqty, $renewalsallowed, $renewalperiod, $norenewalbefore, $reservesallowed, $issuelength,$lengthunit, $hardduedate,$hardduedatecompare,$rentaldiscount,$overduefinescap, $br,$bor,$cat); - } else { - $sth_insert->execute($br,$bor,$cat,$maxissueqty,$renewalsallowed, $renewalperiod, $norenewalbefore, $reservesallowed,$issuelength,$lengthunit,$hardduedate,$hardduedatecompare,$fine,$finedays,$firstremind,$chargeperiod,$rentaldiscount,$overduefinescap); - } -} + Koha::CirculationRules->set_rules( + { + categorycode => $bor eq '*' ? undef : $bor, + itemtype => $itemtype eq '*' ? undef : $itemtype, + branchcode => $br eq '*' ? undef : $br, + rules => $rules, + } + ); + +} elsif ($op eq "set-branch-defaults") { my $categorycode = $input->param('categorycode'); - my $maxissueqty = $input->param('maxissueqty'); + my $patron_maxissueqty = strip_non_numeric( scalar $input->param('patron_maxissueqty') ); + my $patron_maxonsiteissueqty = $input->param('patron_maxonsiteissueqty'); + $patron_maxonsiteissueqty = strip_non_numeric($patron_maxonsiteissueqty); my $holdallowed = $input->param('holdallowed'); + my $hold_fulfillment_policy = $input->param('hold_fulfillment_policy'); my $returnbranch = $input->param('returnbranch'); - $maxissueqty =~ s/\s//g; - $maxissueqty = undef if $maxissueqty !~ /^\d+/; - $holdallowed =~ s/\s//g; - $holdallowed = undef if $holdallowed !~ /^\d+/; + my $max_holds = strip_non_numeric( scalar $input->param('max_holds') ); if ($branch eq "*") { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_circ_rules"); - my $sth_insert = $dbh->prepare("INSERT INTO default_circ_rules - (maxissueqty, holdallowed, returnbranch) - VALUES (?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_circ_rules - SET maxissueqty = ?, holdallowed = ?, returnbranch = ?"); - - $sth_search->execute(); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($maxissueqty, $holdallowed, $returnbranch); - } else { - $sth_insert->execute($maxissueqty, $holdallowed, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => undef, + branchcode => undef, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); + Koha::CirculationRules->set_rules( + { + categorycode => undef, + branchcode => undef, + rules => { + patron_maxissueqty => $patron_maxissueqty, + patron_maxonsiteissueqty => $patron_maxonsiteissueqty, + } + } + ); } else { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_branch_circ_rules - WHERE branchcode = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO default_branch_circ_rules - (branchcode, maxissueqty, holdallowed, returnbranch) - VALUES (?, ?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_circ_rules - SET maxissueqty = ?, holdallowed = ?, returnbranch = ? - WHERE branchcode = ?"); - $sth_search->execute($branch); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($maxissueqty, $holdallowed, $returnbranch, $branch); - } else { - $sth_insert->execute($branch, $maxissueqty, $holdallowed, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => undef, + branchcode => $branch, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); + Koha::CirculationRules->set_rules( + { + categorycode => undef, + branchcode => $branch, + rules => { + patron_maxissueqty => $patron_maxissueqty, + patron_maxonsiteissueqty => $patron_maxonsiteissueqty, + } + } + ); } + Koha::CirculationRules->set_rule( + { + branchcode => $branch, + categorycode => undef, + rule_name => 'max_holds', + rule_value => $max_holds, + } + ); } elsif ($op eq "add-branch-cat") { my $categorycode = $input->param('categorycode'); - my $maxissueqty = $input->param('maxissueqty'); - $maxissueqty =~ s/\s//g; - $maxissueqty = undef if $maxissueqty !~ /^\d+/; + my $patron_maxissueqty = strip_non_numeric( scalar $input->param('patron_maxissueqty') ); + my $patron_maxonsiteissueqty = $input->param('patron_maxonsiteissueqty'); + $patron_maxonsiteissueqty = strip_non_numeric($patron_maxonsiteissueqty); + my $max_holds = $input->param('max_holds'); + $max_holds =~ s/\s//g; + $max_holds = undef if $max_holds !~ /^\d+/; if ($branch eq "*") { if ($categorycode eq "*") { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_circ_rules"); - my $sth_insert = $dbh->prepare("INSERT INTO default_circ_rules - (maxissueqty) - VALUES (?)"); - my $sth_update = $dbh->prepare("UPDATE default_circ_rules - SET maxissueqty = ?"); - - $sth_search->execute(); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($maxissueqty); - } else { - $sth_insert->execute($maxissueqty); - } + Koha::CirculationRules->set_rules( + { + categorycode => undef, + branchcode => undef, + rules => { + max_holds => $max_holds, + patron_maxissueqty => $patron_maxissueqty, + patron_maxonsiteissueqty => $patron_maxonsiteissueqty, + } + } + ); } else { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_borrower_circ_rules - WHERE categorycode = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO default_borrower_circ_rules - (categorycode, maxissueqty) - VALUES (?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_borrower_circ_rules - SET maxissueqty = ? - WHERE categorycode = ?"); - $sth_search->execute($branch); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($maxissueqty, $categorycode); - } else { - $sth_insert->execute($categorycode, $maxissueqty); - } + Koha::CirculationRules->set_rules( + { + categorycode => $categorycode, + branchcode => undef, + rules => { + max_holds => $max_holds, + patron_maxissueqty => $patron_maxissueqty, + patron_maxonsiteissueqty => $patron_maxonsiteissueqty, + } + } + ); } } elsif ($categorycode eq "*") { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_branch_circ_rules - WHERE branchcode = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO default_branch_circ_rules - (branchcode, maxissueqty) - VALUES (?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_circ_rules - SET maxissueqty = ? - WHERE branchcode = ?"); - $sth_search->execute($branch); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($maxissueqty, $branch); + Koha::CirculationRules->set_rules( + { + categorycode => undef, + branchcode => $branch, + rules => { + max_holds => $max_holds, + patron_maxissueqty => $patron_maxissueqty, + patron_maxonsiteissueqty => $patron_maxonsiteissueqty, + } + } + ); + } else { + Koha::CirculationRules->set_rules( + { + categorycode => $categorycode, + branchcode => $branch, + rules => { + max_holds => $max_holds, + patron_maxissueqty => $patron_maxissueqty, + patron_maxonsiteissueqty => $patron_maxonsiteissueqty, + } + } + ); + } +} +elsif ( $op eq "add-open-article-requests-limit" ) { + my $categorycode = $input->param('categorycode'); + my $open_article_requests_limit = strip_non_numeric( scalar $input->param('open_article_requests_limit') ); + + Koha::Exception->throw("No value passed for article request limit") + if not defined $open_article_requests_limit # There is a JS check for that + || $open_article_requests_limit eq ''; + + if ( $branch eq "*" ) { + if ( $categorycode eq "*" ) { + Koha::CirculationRules->set_rules( + { categorycode => undef, + branchcode => undef, + rules => { open_article_requests_limit => $open_article_requests_limit, } + } + ); } else { - $sth_insert->execute($branch, $maxissueqty); + Koha::CirculationRules->set_rules( + { categorycode => $categorycode, + branchcode => undef, + rules => { open_article_requests_limit => $open_article_requests_limit, } + } + ); } + } elsif ( $categorycode eq "*" ) { + Koha::CirculationRules->set_rules( + { categorycode => undef, + branchcode => $branch, + rules => { open_article_requests_limit => $open_article_requests_limit, } + } + ); } else { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM branch_borrower_circ_rules - WHERE branchcode = ? - AND categorycode = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO branch_borrower_circ_rules - (branchcode, categorycode, maxissueqty) - VALUES (?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE branch_borrower_circ_rules - SET maxissueqty = ? - WHERE branchcode = ? - AND categorycode = ?"); - - $sth_search->execute($branch, $categorycode); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($maxissueqty, $branch, $categorycode); + Koha::CirculationRules->set_rules( + { categorycode => $categorycode, + branchcode => $branch, + rules => { open_article_requests_limit => $open_article_requests_limit, } + } + ); + } +} elsif ( $op eq 'del-open-article-requests-limit' ) { + my $categorycode = $input->param('categorycode'); + if ( $branch eq "*" ) { + if ( $categorycode eq "*" ) { + Koha::CirculationRules->set_rules( + { branchcode => undef, + categorycode => undef, + rules => { open_article_requests_limit => undef, } + } + ); } else { - $sth_insert->execute($branch, $categorycode, $maxissueqty); + Koha::CirculationRules->set_rules( + { categorycode => $categorycode, + branchcode => undef, + rules => { open_article_requests_limit => undef, } + } + ); } + } elsif ( $categorycode eq "*" ) { + Koha::CirculationRules->set_rules( + { branchcode => $branch, + categorycode => undef, + rules => { open_article_requests_limit => undef, } + } + ); + } else { + Koha::CirculationRules->set_rules( + { categorycode => $categorycode, + branchcode => $branch, + rules => { open_article_requests_limit => undef, } + } + ); } } +elsif ( $op eq "set-article-request-fee" ) { + + my $category = $input->param('article_request_fee_category'); + my $fee = strip_non_numeric( scalar $input->param('article_request_fee') ); + + Koha::Exception->throw("No value passed for article request fee") + if not defined $fee # There is a JS check for that + || $fee eq ''; + + Koha::CirculationRules->set_rules( + { categorycode => ( $category eq '*' ) ? undef : $category, + branchcode => ( $branch eq '*' ) ? undef : $branch, + rules => { article_request_fee => $fee }, + } + ); + +} elsif ( $op eq 'del-article-request-fee' ) { + + my $category = $input->param('article_request_fee_category'); + + Koha::CirculationRules->set_rules( + { categorycode => ( $category eq '*' ) ? undef : $category, + branchcode => ( $branch eq '*' ) ? undef : $branch, + rules => { article_request_fee => undef }, + } + ); +} elsif ($op eq "add-branch-item") { - my $itemtype = $input->param('itemtype'); - my $holdallowed = $input->param('holdallowed'); - my $returnbranch = $input->param('returnbranch'); - $holdallowed =~ s/\s//g; - $holdallowed = undef if $holdallowed !~ /^\d+/; + my $itemtype = $input->param('itemtype'); + my $holdallowed = $input->param('holdallowed'); + my $hold_fulfillment_policy = $input->param('hold_fulfillment_policy'); + my $returnbranch = $input->param('returnbranch'); if ($branch eq "*") { if ($itemtype eq "*") { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_circ_rules"); - my $sth_insert = $dbh->prepare("INSERT INTO default_circ_rules - (holdallowed, returnbranch) - VALUES (?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_circ_rules - SET holdallowed = ?, returnbranch = ?"); - - $sth_search->execute(); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $returnbranch); - } else { - $sth_insert->execute($holdallowed, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => undef, + branchcode => undef, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); } else { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_branch_item_rules - WHERE itemtype = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO default_branch_item_rules - (itemtype, holdallowed, returnbranch) - VALUES (?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_item_rules - SET holdallowed = ?, returnbranch = ? - WHERE itemtype = ?"); - $sth_search->execute($itemtype); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $returnbranch, $itemtype); - } else { - $sth_insert->execute($itemtype, $holdallowed, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => $itemtype, + branchcode => undef, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); } } elsif ($itemtype eq "*") { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM default_branch_circ_rules - WHERE branchcode = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO default_branch_circ_rules - (branchcode, holdallowed, returnbranch) - VALUES (?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_circ_rules - SET holdallowed = ?, returnbranch = ? - WHERE branchcode = ?"); - $sth_search->execute($branch); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $returnbranch, $branch); - } else { - $sth_insert->execute($branch, $holdallowed, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => undef, + branchcode => $branch, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); } else { - my $sth_search = $dbh->prepare("SELECT count(*) AS total - FROM branch_item_rules - WHERE branchcode = ? - AND itemtype = ?"); - my $sth_insert = $dbh->prepare("INSERT INTO branch_item_rules - (branchcode, itemtype, holdallowed, returnbranch) - VALUES (?, ?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE branch_item_rules - SET holdallowed = ?, returnbranch = ? - WHERE branchcode = ? - AND itemtype = ?"); - - $sth_search->execute($branch, $itemtype); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $returnbranch, $branch, $itemtype); - } else { - $sth_insert->execute($branch, $itemtype, $holdallowed, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => $itemtype, + branchcode => $branch, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); } } - -my $branches = GetBranches(); -my @branchloop; -for my $thisbranch (sort { $branches->{$a}->{branchname} cmp $branches->{$b}->{branchname} } keys %$branches) { - push @branchloop, { - value => $thisbranch, - selected => $thisbranch eq $branch, - branchname => $branches->{$thisbranch}->{'branchname'}, - }; -} - -my $sth=$dbh->prepare("SELECT description,categorycode FROM categories ORDER BY description"); -$sth->execute; -my @category_loop; -while (my $data=$sth->fetchrow_hashref){ - push @category_loop,$data; -} - -$sth->finish; -$sth=$dbh->prepare("SELECT description,itemtype FROM itemtypes ORDER BY description"); -$sth->execute; -# $i=0; -my @row_loop; -my @itemtypes; -while (my $row=$sth->fetchrow_hashref){ - push @itemtypes,$row; -} - -my $sth2 = $dbh->prepare(" - SELECT issuingrules.*, itemtypes.description AS humanitemtype, categories.description AS humancategorycode - FROM issuingrules - LEFT JOIN itemtypes - ON (itemtypes.itemtype = issuingrules.itemtype) - LEFT JOIN categories - ON (categories.categorycode = issuingrules.categorycode) - WHERE issuingrules.branchcode = ? -"); -$sth2->execute($branch); - -while (my $row = $sth2->fetchrow_hashref) { - $row->{'current_branch'} ||= $row->{'branchcode'}; - $row->{'humanitemtype'} ||= $row->{'itemtype'}; - $row->{'default_humanitemtype'} = 1 if $row->{'humanitemtype'} eq '*'; - $row->{'humancategorycode'} ||= $row->{'categorycode'}; - $row->{'default_humancategorycode'} = 1 if $row->{'humancategorycode'} eq '*'; - $row->{'fine'} = sprintf('%.2f', $row->{'fine'}); - if ($row->{'hardduedate'} ne '0000-00-00') { - $row->{'hardduedate'} = format_date( $row->{'hardduedate'}); - $row->{'hardduedatebefore'} = 1 if ($row->{'hardduedatecompare'} == -1); - $row->{'hardduedateexact'} = 1 if ($row->{'hardduedatecompare'} == 0); - $row->{'hardduedateafter'} = 1 if ($row->{'hardduedatecompare'} == 1); +elsif ( $op eq 'mod-refund-lost-item-fee-rule' ) { + + my $lostreturn = $input->param('lostreturn'); + + if ( $lostreturn eq '*' ) { + if ( $branch ne '*' ) { + # only do something for $lostreturn eq '*' if branch-specific + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + rules => { + lostreturn => undef + } + } + ); + } } else { - $row->{'hardduedate'} = 0; + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + rules => { + lostreturn => $lostreturn + } + } + ); } - push @row_loop, $row; -} -$sth->finish; - -my @sorted_row_loop = sort by_category_and_itemtype @row_loop; - -my $sth_branch_cat; -if ($branch eq "*") { - $sth_branch_cat = $dbh->prepare(" - SELECT default_borrower_circ_rules.*, categories.description AS humancategorycode - FROM default_borrower_circ_rules - JOIN categories USING (categorycode) - - "); - $sth_branch_cat->execute(); -} else { - $sth_branch_cat = $dbh->prepare(" - SELECT branch_borrower_circ_rules.*, categories.description AS humancategorycode - FROM branch_borrower_circ_rules - JOIN categories USING (categorycode) - WHERE branch_borrower_circ_rules.branchcode = ? - "); - $sth_branch_cat->execute($branch); } -my @branch_cat_rules = (); -while (my $row = $sth_branch_cat->fetchrow_hashref) { - push @branch_cat_rules, $row; -} -my @sorted_branch_cat_rules = sort { $a->{'humancategorycode'} cmp $b->{'humancategorycode'} } @branch_cat_rules; +my $refundLostItemFeeRule = Koha::CirculationRules->find({ branchcode => ($branch eq '*') ? undef : $branch, rule_name => 'lostreturn' }); +my $defaultLostItemFeeRule = Koha::CirculationRules->find({ branchcode => undef, rule_name => 'lostreturn' }); +$template->param( + refundLostItemFeeRule => $refundLostItemFeeRule, + defaultRefundRule => $defaultLostItemFeeRule ? $defaultLostItemFeeRule->rule_value : 'refund' +); -# note undef maxissueqty so that template can deal with them -foreach my $entry (@sorted_branch_cat_rules, @sorted_row_loop) { - $entry->{unlimited_maxissueqty} = 1 unless defined($entry->{maxissueqty}); -} +my $patron_categories = Koha::Patron::Categories->search({}, { order_by => ['description'] }); -@sorted_row_loop = sort by_category_and_itemtype @row_loop; - -my $sth_branch_item; -if ($branch eq "*") { - $sth_branch_item = $dbh->prepare(" - SELECT default_branch_item_rules.*, itemtypes.description AS humanitemtype - FROM default_branch_item_rules - JOIN itemtypes USING (itemtype) - "); - $sth_branch_item->execute(); -} else { - $sth_branch_item = $dbh->prepare(" - SELECT branch_item_rules.*, itemtypes.description AS humanitemtype - FROM branch_item_rules - JOIN itemtypes USING (itemtype) - WHERE branch_item_rules.branchcode = ? - "); - $sth_branch_item->execute($branch); -} - -my @branch_item_rules = (); -while (my $row = $sth_branch_item->fetchrow_hashref) { - push @branch_item_rules, $row; -} -my @sorted_branch_item_rules = sort { $a->{'humanitemtype'} cmp $b->{'humanitemtype'} } @branch_item_rules; - -# note undef holdallowed so that template can deal with them -foreach my $entry (@sorted_branch_item_rules) { - $entry->{holdallowed_any} = 1 if($entry->{holdallowed} == 2); - $entry->{holdallowed_same} = 1 if($entry->{holdallowed} == 1); -} +my $itemtypes = Koha::ItemTypes->search_with_localization; -$template->param(show_branch_cat_rule_form => 1); -$template->param(branch_item_rule_loop => \@sorted_branch_item_rules); -$template->param(branch_cat_rule_loop => \@sorted_branch_cat_rules); - -my $sth_defaults; -if ($branch eq "*") { - $sth_defaults = $dbh->prepare(" - SELECT * - FROM default_circ_rules - "); - $sth_defaults->execute(); -} else { - $sth_defaults = $dbh->prepare(" - SELECT * - FROM default_branch_circ_rules - WHERE branchcode = ? - "); - $sth_defaults->execute($branch); -} +my $humanbranch = ( $branch ne '*' ? $branch : undef ); -my $defaults = $sth_defaults->fetchrow_hashref; +my $all_rules = Koha::CirculationRules->search({ branchcode => $humanbranch }); +my $definedbranch = $all_rules->count ? 1 : 0; -if ($defaults) { - $template->param(default_holdallowed_none => 1) if($defaults->{holdallowed} == 0); - $template->param(default_holdallowed_same => 1) if($defaults->{holdallowed} == 1); - $template->param(default_holdallowed_any => 1) if($defaults->{holdallowed} == 2); - $template->param(default_maxissueqty => $defaults->{maxissueqty}); - $template->param(default_returnbranch => $defaults->{returnbranch}); +my $rules = {}; +while ( my $r = $all_rules->next ) { + $r = $r->unblessed; + $rules->{ $r->{categorycode} // '' }->{ $r->{itemtype} // '' }->{ $r->{rule_name} } = $r->{rule_value}; } -$template->param(default_rules => ($defaults ? 1 : 0)); +$template->param(show_branch_cat_rule_form => 1); -$template->param(categoryloop => \@category_loop, - itemtypeloop => \@itemtypes, - rules => \@sorted_row_loop, - branchloop => \@branchloop, - humanbranch => ($branch ne '*' ? $branches->{$branch}->{branchname} : ''), - current_branch => $branch, - definedbranch => scalar(@sorted_row_loop)>0 - ); +$template->param( + patron_categories => $patron_categories, + itemtypeloop => $itemtypes, + humanbranch => $humanbranch, + current_branch => $branch, + definedbranch => $definedbranch, + all_rules => $rules, +); output_html_with_http_headers $input, $cookie, $template->output; exit 0; @@ -529,11 +719,18 @@ sub by_category { sub by_itemtype { my ($a, $b) = @_; - if ($a->{'default_humanitemtype'}) { - return ($b->{'default_humanitemtype'} ? 0 : 1); - } elsif ($b->{'default_humanitemtype'}) { + if ($a->{default_translated_description}) { + return ($b->{'default_translated_description'} ? 0 : 1); + } elsif ($b->{'default_translated_description'}) { return -1; } else { - return $a->{'humanitemtype'} cmp $b->{'humanitemtype'}; + return lc $a->{'translated_description'} cmp lc $b->{'translated_description'}; } } + +sub strip_non_numeric { + my $string = shift; + $string =~ s/\s//g; + $string = '' if $string !~ /^\d+/; + return $string; +}