X-Git-Url: http://koha-dev.rot13.org:8081/gitweb/?a=blobdiff_plain;f=admin%2Fsmart-rules.pl;h=b71179437fe8d45aeb554c79a8f7f2b5b4be6d6b;hb=0ec29e5d4ecdf5dd3156b53320eac1250d065e3b;hp=e9c1bf121d075e6ed4b167b1c0288ea02d0e0552;hpb=d1303ca834dd0b08fc1d44476cfbbb8b729b6165;p=koha-ffzg.git diff --git a/admin/smart-rules.pl b/admin/smart-rules.pl index e9c1bf121d..b71179437f 100755 --- a/admin/smart-rules.pl +++ b/admin/smart-rules.pl @@ -20,17 +20,11 @@ use Modern::Perl; use CGI qw ( -utf8 ); use C4::Context; -use C4::Output; -use C4::Auth; -use C4::Koha; -use C4::Debug; -use Koha::DateUtils; +use C4::Output qw( output_html_with_http_headers ); +use C4::Auth qw( get_template_and_user ); +use Koha::Exception; use Koha::Database; -use Koha::IssuingRule; -use Koha::IssuingRules; use Koha::Logger; -use Koha::RefundLostItemFeeRule; -use Koha::RefundLostItemFeeRules; use Koha::Libraries; use Koha::CirculationRules; use Koha::Patron::Categories; @@ -46,9 +40,7 @@ my ($template, $loggedinuser, $cookie) = 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'); @@ -69,67 +61,191 @@ my $can_edit_from_any_library = $logged_in_patron->has_permission( {parameters = $template->param( restricted_to_own_library => not $can_edit_from_any_library ); $branch = C4::Context::mybranch() unless $can_edit_from_any_library; -$branch = '*' if $branch eq 'NO_LIBRARY_SET'; - my $op = $input->param('op') || q{}; my $language = C4::Languages::getlanguage(); my $cache = Koha::Caches->get_instance; -$cache->clear_from_cache( Koha::IssuingRules::GUESSED_ITEMTYPES_KEY ); +$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 { + 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( - { - categorycode => $categorycode eq '*' ? undef : $categorycode, - branchcode => $branch eq '*' ? undef : $branch, - itemtype => undef, - rules => { - max_holds => undef, - patron_maxissueqty => undef, - patron_maxonsiteissueqty => undef, + 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 { + 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 @@ -139,53 +255,49 @@ elsif ($op eq 'add') { my $itemtype = $input->param('itemtype'); # item type my $fine = $input->param('fine'); my $finedays = $input->param('finedays'); - my $maxsuspensiondays = $input->param('maxsuspensiondays'); - $maxsuspensiondays = undef if $maxsuspensiondays eq q||; + my $maxsuspensiondays = $input->param('maxsuspensiondays') || q{}; my $suspension_chargeperiod = $input->param('suspension_chargeperiod') || 1; my $firstremind = $input->param('firstremind'); my $chargeperiod = $input->param('chargeperiod'); my $chargeperiod_charge_at = $input->param('chargeperiod_charge_at'); - my $maxissueqty = $input->param('maxissueqty'); - my $maxonsiteissueqty = $input->param('maxonsiteissueqty'); + 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 = defined $input->param('unseen_renewals_allowed') ? strip_non_numeric( scalar $input->param('unseen_renewals_allowed') ) : q{}; my $renewalperiod = $input->param('renewalperiod'); my $norenewalbefore = $input->param('norenewalbefore'); - $norenewalbefore = undef if $norenewalbefore =~ /^\s*$/; + $norenewalbefore = q{} 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 = undef if $no_auto_renewal_after =~ /^\s*$/; - my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') || undef; - $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 ); - $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 = $input->param('reservesallowed'); - my $holds_per_record = $input->param('holds_per_record'); - my $holds_per_day = $input->param('holds_per_day'); - $holds_per_day =~ s/\s//g; - $holds_per_day = undef if $holds_per_day !~ /^\d+/; + $no_auto_renewal_after = q{} if $no_auto_renewal_after =~ /^\s*$/; + my $no_auto_renewal_after_hard_limit = $input->param('no_auto_renewal_after_hard_limit') || q{}; + 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; - $maxissueqty =~ s/\s//g; - $maxissueqty = undef if $maxissueqty !~ /^\d+/; - $maxonsiteissueqty =~ s/\s//g; - $maxonsiteissueqty = undef if $maxonsiteissueqty !~ /^\d+/; - my $issuelength = $input->param('issuelength'); - $issuelength = $issuelength eq q{} ? undef : $issuelength; + my $issuelength = $input->param('issuelength') || 0; + my $daysmode = $input->param('daysmode'); my $lengthunit = $input->param('lengthunit'); - my $hardduedate = $input->param('hardduedate') || undef; - $hardduedate = eval { dt_from_string( $input->param('hardduedate') ) } if ( $hardduedate ); - $hardduedate = output_pref( { dt => $hardduedate, dateonly => 1, dateformat => 'iso' } ) if ( $hardduedate ); + my $hardduedate = $input->param('hardduedate') || q{}; my $hardduedatecompare = $input->param('hardduedatecompare'); - my $rentaldiscount = $input->param('rentaldiscount'); + my $rentaldiscount = $input->param('rentaldiscount') || 0; my $opacitemholds = $input->param('opacitemholds') || 0; my $article_requests = $input->param('article_requests') || 'no'; - my $overduefinescap = $input->param('overduefinescap') || undef; - my $cap_fine_to_replacement_price = $input->param('cap_fine_to_replacement_price') eq 'on'; + my $overduefinescap = $input->param('overduefinescap') || q{}; + my $cap_fine_to_replacement_price = ($input->param('cap_fine_to_replacement_price') || q{}) eq 'on'; my $note = $input->param('note'); - $debug and warn "Adding $br, $bor, $itemtype, $fine, $maxissueqty, $maxonsiteissueqty, $cap_fine_to_replacement_price"; - - my $params = { - branchcode => $br, - categorycode => $bor, - itemtype => $itemtype, + my $decreaseloanholds = $input->param('decreaseloanholds') || q{}; + 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, @@ -193,7 +305,13 @@ elsif ($op eq 'add') { 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, @@ -202,108 +320,80 @@ elsif ($op eq 'add') { reservesallowed => $reservesallowed, holds_per_record => $holds_per_record, holds_per_day => $holds_per_day, - issuelength => $issuelength, - lengthunit => $lengthunit, - hardduedate => $hardduedate, - hardduedatecompare => $hardduedatecompare, - rentaldiscount => $rentaldiscount, 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, }; - my $issuingrule = Koha::IssuingRules->find({categorycode => $bor, itemtype => $itemtype, branchcode => $br}); - if ($issuingrule) { - $issuingrule->set($params)->store(); - } else { - Koha::IssuingRule->new()->set($params)->store(); - } - Koha::CirculationRules->set_rules( { - categorycode => $bor, - itemtype => $itemtype, - branchcode => $br, - rules => { - maxissueqty => $maxissueqty, - maxonsiteissueqty => $maxonsiteissueqty, - } + 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 $patron_maxissueqty = $input->param('patron_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'); - my $max_holds = $input->param('max_holds'); - $patron_maxissueqty =~ s/\s//g; - $patron_maxissueqty = '' if $patron_maxissueqty !~ /^\d+/; - $patron_maxonsiteissueqty =~ s/\s//g; - $patron_maxonsiteissueqty = '' if $patron_maxonsiteissueqty !~ /^\d+/; - $holdallowed =~ s/\s//g; - $holdallowed = undef if $holdallowed !~ /^\d+/; - $max_holds =~ s/\s//g; - $max_holds = '' if $max_holds !~ /^\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 - (holdallowed, hold_fulfillment_policy, returnbranch) - VALUES (?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_circ_rules - SET holdallowed = ?, hold_fulfillment_policy = ?, returnbranch = ?"); - - $sth_search->execute(); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $hold_fulfillment_policy, $returnbranch); - } else { - $sth_insert->execute($holdallowed, $hold_fulfillment_policy, $returnbranch); - } - Koha::CirculationRules->set_rules( { - categorycode => undef, 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, holdallowed, hold_fulfillment_policy, returnbranch) - VALUES (?, ?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_circ_rules - SET holdallowed = ?, hold_fulfillment_policy = ?, returnbranch = ? - WHERE branchcode = ?"); - $sth_search->execute($branch); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $hold_fulfillment_policy, $returnbranch, $branch); - } else { - $sth_insert->execute($branch, $holdallowed, $hold_fulfillment_policy, $returnbranch); - } - Koha::CirculationRules->set_rules( { - categorycode => undef, 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, } @@ -314,7 +404,6 @@ elsif ($op eq "set-branch-defaults") { { branchcode => $branch, categorycode => undef, - itemtype => undef, rule_name => 'max_holds', rule_value => $max_holds, } @@ -322,13 +411,10 @@ elsif ($op eq "set-branch-defaults") { } elsif ($op eq "add-branch-cat") { my $categorycode = $input->param('categorycode'); - my $patron_maxissueqty = $input->param('patron_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 $max_holds = $input->param('max_holds'); - $patron_maxissueqty =~ s/\s//g; - $patron_maxissueqty = '' if $patron_maxissueqty !~ /^\d+/; - $patron_maxonsiteissueqty =~ s/\s//g; - $patron_maxonsiteissueqty = '' if $patron_maxonsiteissueqty !~ /^\d+/; $max_holds =~ s/\s//g; $max_holds = undef if $max_holds !~ /^\d+/; @@ -337,7 +423,6 @@ elsif ($op eq "add-branch-cat") { Koha::CirculationRules->set_rules( { categorycode => undef, - itemtype => undef, branchcode => undef, rules => { max_holds => $max_holds, @@ -349,9 +434,8 @@ elsif ($op eq "add-branch-cat") { } else { Koha::CirculationRules->set_rules( { - branchcode => undef, categorycode => $categorycode, - itemtype => undef, + branchcode => undef, rules => { max_holds => $max_holds, patron_maxissueqty => $patron_maxissueqty, @@ -364,7 +448,6 @@ elsif ($op eq "add-branch-cat") { Koha::CirculationRules->set_rules( { categorycode => undef, - itemtype => undef, branchcode => $branch, rules => { max_holds => $max_holds, @@ -377,7 +460,6 @@ elsif ($op eq "add-branch-cat") { Koha::CirculationRules->set_rules( { categorycode => $categorycode, - itemtype => undef, branchcode => $branch, rules => { max_holds => $max_holds, @@ -388,248 +470,286 @@ elsif ($op eq "add-branch-cat") { ); } } +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 q{}; + + if ( $branch eq "*" ) { + if ( $categorycode eq "*" ) { + Koha::CirculationRules->set_rules( + { categorycode => undef, + branchcode => undef, + rules => { open_article_requests_limit => $open_article_requests_limit, } + } + ); + } else { + 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 { + 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 { + 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 q{}; + + 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 $hold_fulfillment_policy = $input->param('hold_fulfillment_policy'); my $returnbranch = $input->param('returnbranch'); - $holdallowed =~ s/\s//g; - $holdallowed = undef if $holdallowed !~ /^\d+/; - 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, hold_fulfillment_policy, returnbranch) - VALUES (?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_circ_rules - SET holdallowed = ?, hold_fulfillment_policy = ?, returnbranch = ?"); - - $sth_search->execute(); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $hold_fulfillment_policy, $returnbranch); - } else { - $sth_insert->execute($holdallowed, $hold_fulfillment_policy, $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, hold_fulfillment_policy, returnbranch) - VALUES (?, ?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_item_rules - SET holdallowed = ?, hold_fulfillment_policy = ?, returnbranch = ? - WHERE itemtype = ?"); - $sth_search->execute($itemtype); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $hold_fulfillment_policy, $returnbranch, $itemtype); - } else { - $sth_insert->execute($itemtype, $holdallowed, $hold_fulfillment_policy, $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, hold_fulfillment_policy, returnbranch) - VALUES (?, ?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE default_branch_circ_rules - SET holdallowed = ?, hold_fulfillment_policy = ?, returnbranch = ? - WHERE branchcode = ?"); - $sth_search->execute($branch); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $hold_fulfillment_policy, $returnbranch, $branch); - } else { - $sth_insert->execute($branch, $holdallowed, $hold_fulfillment_policy, $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, hold_fulfillment_policy, returnbranch) - VALUES (?, ?, ?, ?, ?)"); - my $sth_update = $dbh->prepare("UPDATE branch_item_rules - SET holdallowed = ?, hold_fulfillment_policy = ?, returnbranch = ? - WHERE branchcode = ? - AND itemtype = ?"); - - $sth_search->execute($branch, $itemtype); - my $res = $sth_search->fetchrow_hashref(); - if ($res->{total}) { - $sth_update->execute($holdallowed, $hold_fulfillment_policy, $returnbranch, $branch, $itemtype); - } else { - $sth_insert->execute($branch, $itemtype, $holdallowed, $hold_fulfillment_policy, $returnbranch); - } + Koha::CirculationRules->set_rules( + { + itemtype => $itemtype, + branchcode => $branch, + rules => { + holdallowed => $holdallowed, + hold_fulfillment_policy => $hold_fulfillment_policy, + returnbranch => $returnbranch, + } + } + ); } } elsif ( $op eq 'mod-refund-lost-item-fee-rule' ) { - my $refund = $input->param('refund'); + my $lostreturn = $input->param('lostreturn'); - if ( $refund eq '*' ) { + if ( $lostreturn eq '*' ) { if ( $branch ne '*' ) { - # only do something for $refund eq '*' if branch-specific - eval { - # Delete it so it picks the default - Koha::RefundLostItemFeeRules->find({ - branchcode => $branch - })->delete; - }; + # only do something for $lostreturn eq '*' if branch-specific + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + rules => { + lostreturn => undef + } + } + ); + } + } else { + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + rules => { + lostreturn => $lostreturn + } + } + ); + } + + my $processingreturn = $input->param('processingreturn'); + + if ( $processingreturn eq '*' ) { + if ( $branch ne '*' ) { + # only do something for $processingreturn eq '*' if branch-specific + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + rules => { + processingreturn => undef + } + } + ); } } else { - my $refundRule = - Koha::RefundLostItemFeeRules->find({ - branchcode => $branch - }) // Koha::RefundLostItemFeeRule->new; - $refundRule->set({ - branchcode => $branch, - refund => $refund - })->store; + Koha::CirculationRules->set_rules( + { + branchcode => $branch, + rules => { + processingreturn => $processingreturn + } + } + ); } +} elsif ( $op eq "set-waiting-hold-cancellation" ) { + + my $category = $input->param('waiting_hold_cancellation_category'); + my $itemtype = $input->param('waiting_hold_cancellation_itemtype'); + my $policy = strip_non_numeric( scalar $input->param('waiting_hold_cancellation_policy') ) + ? 1 + : 0; + + Koha::Exception->throw("No value passed for waiting holds cancellation policy") + if not defined $policy # There is a JS check for that + || $policy eq ''; + + Koha::CirculationRules->set_rules( + { categorycode => ( $category eq '*' ) ? undef : $category, + itemtype => ( $itemtype eq '*' ) ? undef : $itemtype, + branchcode => ( $branch eq '*' ) ? undef : $branch, + rules => { waiting_hold_cancellation => $policy }, + } + ); + +} elsif ( $op eq 'del-waiting-hold-cancellation' ) { + + my $category = $input->param('waiting_hold_cancellation_category'); + my $itemtype = $input->param('waiting_hold_cancellation_itemtype'); + + Koha::CirculationRules->set_rules( + { categorycode => ( $category eq '*' ) ? undef : $category, + itemtype => ( $itemtype eq '*' ) ? undef : $itemtype, + branchcode => ( $branch eq '*' ) ? undef : $branch, + rules => { waiting_hold_cancellation => undef }, + } + ); } -my $refundLostItemFeeRule = Koha::RefundLostItemFeeRules->find({ branchcode => $branch }); + +my $refundLostItemFeeRule = Koha::CirculationRules->find({ branchcode => ($branch eq '*') ? undef : $branch, rule_name => 'lostreturn' }); +my $defaultLostItemFeeRule = Koha::CirculationRules->find({ branchcode => undef, rule_name => 'lostreturn' }); +my $refundProcessingFeeRule = Koha::CirculationRules->find({ branchcode => ($branch eq '*') ? undef : $branch, rule_name => 'processingreturn' }); +my $defaultProcessingFeeRule = Koha::CirculationRules->find({ branchcode => undef, rule_name => 'processingreturn' }); $template->param( refundLostItemFeeRule => $refundLostItemFeeRule, - defaultRefundRule => Koha::RefundLostItemFeeRules->_default_rule + defaultRefundRule => $defaultLostItemFeeRule ? $defaultLostItemFeeRule->rule_value : 'refund', + refundProcessingFeeRule => $refundProcessingFeeRule, + defaultProcessingRefundRule => $defaultProcessingFeeRule ? $defaultProcessingFeeRule->rule_value : 'refund', ); my $patron_categories = Koha::Patron::Categories->search({}, { order_by => ['description'] }); -my @row_loop; my $itemtypes = Koha::ItemTypes->search_with_localization; -my $sth2 = $dbh->prepare(" - SELECT issuingrules.*, - itemtypes.description AS humanitemtype, - categories.description AS humancategorycode, - COALESCE( localization.translation, itemtypes.description ) AS translated_description - FROM issuingrules - LEFT JOIN itemtypes - ON (itemtypes.itemtype = issuingrules.itemtype) - LEFT JOIN categories - ON (categories.categorycode = issuingrules.categorycode) - LEFT JOIN localization ON issuingrules.itemtype = localization.code - AND localization.entity = 'itemtypes' - AND localization.lang = ? - WHERE issuingrules.branchcode = ? -"); -$sth2->execute($language, $branch); - -while (my $row = $sth2->fetchrow_hashref) { - $row->{'current_branch'} ||= $row->{'branchcode'}; - $row->{humanitemtype} ||= $row->{itemtype}; - $row->{default_translated_description} = 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'} && $row->{'hardduedate'} ne '0000-00-00') { - my $harddue_dt = eval { dt_from_string( $row->{'hardduedate'} ) }; - $row->{'hardduedate'} = eval { output_pref( { dt => $harddue_dt, dateonly => 1 } ) } if ( $harddue_dt ); - $row->{'hardduedatebefore'} = 1 if ($row->{'hardduedatecompare'} == -1); - $row->{'hardduedateexact'} = 1 if ($row->{'hardduedatecompare'} == 0); - $row->{'hardduedateafter'} = 1 if ($row->{'hardduedatecompare'} == 1); - } else { - $row->{'hardduedate'} = 0; - } - if ($row->{no_auto_renewal_after_hard_limit}) { - my $dt = eval { dt_from_string( $row->{no_auto_renewal_after_hard_limit} ) }; - $row->{no_auto_renewal_after_hard_limit} = eval { output_pref( { dt => $dt, dateonly => 1 } ) } if $dt; - } - - push @row_loop, $row; -} - -my @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.*, - COALESCE( localization.translation, itemtypes.description ) AS translated_description - FROM default_branch_item_rules - JOIN itemtypes USING (itemtype) - LEFT JOIN localization ON itemtypes.itemtype = localization.code - AND localization.entity = 'itemtypes' - AND localization.lang = ? - "); - $sth_branch_item->execute($language); -} else { - $sth_branch_item = $dbh->prepare(" - SELECT branch_item_rules.*, - COALESCE( localization.translation, itemtypes.description ) AS translated_description - FROM branch_item_rules - JOIN itemtypes USING (itemtype) - LEFT JOIN localization ON itemtypes.itemtype = localization.code - AND localization.entity = 'itemtypes' - AND localization.lang = ? - WHERE branch_item_rules.branchcode = ? - "); - $sth_branch_item->execute($language, $branch); -} +my $humanbranch = ( $branch ne '*' ? $branch : undef ); -my @branch_item_rules = (); -while (my $row = $sth_branch_item->fetchrow_hashref) { - push @branch_item_rules, $row; -} -my @sorted_branch_item_rules = sort { lc $a->{translated_description} cmp lc $b->{translated_description} } @branch_item_rules; +my $all_rules = Koha::CirculationRules->search({ branchcode => $humanbranch }); +my $definedbranch = $all_rules->count ? 1 : 0; -# 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 $rules = {}; +while ( my $r = $all_rules->next ) { + $r = $r->unblessed; + $rules->{ $r->{categorycode} // q{} }->{ $r->{itemtype} // q{} }->{ $r->{rule_name} } = $r->{rule_value}; } $template->param(show_branch_cat_rule_form => 1); -$template->param(branch_item_rule_loop => \@sorted_branch_item_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 $defaults = $sth_defaults->fetchrow_hashref; - -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_hold_fulfillment_policy => $defaults->{hold_fulfillment_policy} ); - $template->param( default_maxissueqty => $defaults->{maxissueqty} ); - $template->param( default_maxonsiteissueqty => $defaults->{maxonsiteissueqty} ); - $template->param( default_returnbranch => $defaults->{returnbranch} ); -} - -$template->param(default_rules => ($defaults ? 1 : 0)); $template->param( patron_categories => $patron_categories, - itemtypeloop => $itemtypes, - rules => \@sorted_row_loop, - humanbranch => ($branch ne '*' ? $branch : ''), - current_branch => $branch, - definedbranch => scalar(@sorted_row_loop)>0 - ); + itemtypeloop => $itemtypes, + humanbranch => $humanbranch, + current_branch => $branch, + definedbranch => $definedbranch, + all_rules => $rules, +); output_html_with_http_headers $input, $cookie, $template->output; exit 0; @@ -663,3 +783,10 @@ sub by_itemtype { return lc $a->{'translated_description'} cmp lc $b->{'translated_description'}; } } + +sub strip_non_numeric { + my $string = shift; + $string =~ s/\s//g; + $string = q{} if $string !~ /^\d+/; + return $string; +}