X-Git-Url: http://koha-dev.rot13.org:8081/gitweb/?a=blobdiff_plain;f=admin%2Fsmart-rules.pl;h=b7f2ae643ec4f7b4bdfa0fd523525808fd6b8622;hb=2be3e079708e5beb0453e3534a9098af710cb3e5;hp=6bea920dd909b1fb45a1d8ade4aa2dfdb0cf11d7;hpb=a28e1928d3b7efe1503fee2f9cc077954353e5b7;p=koha-ffzg.git

diff --git a/admin/smart-rules.pl b/admin/smart-rules.pl
index 6bea920dd9..b7f2ae643e 100755
--- a/admin/smart-rules.pl
+++ b/admin/smart-rules.pl
@@ -20,14 +20,12 @@
 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::DateUtils qw( dt_from_string output_pref );
 use Koha::Database;
 use Koha::Logger;
-use Koha::RefundLostItemFeeRules;
 use Koha::Libraries;
 use Koha::CirculationRules;
 use Koha::Patron::Categories;
@@ -43,9 +41,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');
@@ -75,7 +71,6 @@ $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";
 
     Koha::CirculationRules->set_rules(
         {
@@ -94,10 +89,12 @@ if ($op eq 'delete') {
                 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,
@@ -112,6 +109,12 @@ if ($op eq 'delete') {
                 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,
             }
         }
     );
@@ -161,6 +164,7 @@ elsif ($op eq 'delete-branch-cat') {
                 branchcode   => $branch,
                 categorycode => undef,
                 rules        => {
+                    max_holds                => undef,
                     patron_maxissueqty       => undef,
                     patron_maxonsiteissueqty => undef,
                 }
@@ -169,11 +173,11 @@ elsif ($op eq 'delete-branch-cat') {
         Koha::CirculationRules->set_rules(
             {
                 branchcode   => $branch,
+                itemtype     => undef,
                 rules        => {
                     holdallowed             => undef,
                     hold_fulfillment_policy => undef,
                     returnbranch            => undef,
-                    max_holds               => undef,
                 }
             }
         );
@@ -252,16 +256,15 @@ 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||;
-    $maxsuspensiondays = '' if $maxsuspensiondays eq q||;
+    my $maxsuspensiondays = $input->param('maxsuspensiondays') || '';
     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  = strip_non_numeric($input->param('maxissueqty'));
-    my $maxonsiteissueqty  = strip_non_numeric($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  = $input->param('unseen_renewals_allowed');
     my $renewalperiod    = $input->param('renewalperiod');
     my $norenewalbefore  = $input->param('norenewalbefore');
     $norenewalbefore = '' if $norenewalbefore =~ /^\s*$/;
@@ -269,26 +272,33 @@ elsif ($op eq 'add') {
     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( $input->param('no_auto_renewal_after_hard_limit') ) } if ( $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($input->param('reservesallowed'));
-    my $holds_per_record = strip_non_numeric($input->param('holds_per_record'));
-    my $holds_per_day    = strip_non_numeric($input->param('holds_per_day'));
+    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') || undef;
-    $hardduedate = eval { dt_from_string( $input->param('hardduedate') ) } if ( $hardduedate );
+    $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 $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 $cap_fine_to_replacement_price = ($input->param('cap_fine_to_replacement_price') || '') eq 'on';
     my $note = $input->param('note');
-    $debug and warn "Adding $br, $bor, $itemtype, $fine, $maxissueqty, $maxonsiteissueqty, $cap_fine_to_replacement_price";
+    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,
@@ -302,10 +312,12 @@ elsif ($op eq 'add') {
         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,
@@ -320,6 +332,13 @@ elsif ($op eq 'add') {
         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,
     };
 
     Koha::CirculationRules->set_rules(
@@ -334,15 +353,13 @@ elsif ($op eq 'add') {
 }
 elsif ($op eq "set-branch-defaults") {
     my $categorycode  = $input->param('categorycode');
-    my $patron_maxissueqty   = strip_non_numeric($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 = strip_non_numeric($input->param('max_holds'));
-    $holdallowed =~ s/\s//g;
-    $holdallowed = undef if $holdallowed !~ /^\d+/;
+    my $max_holds = strip_non_numeric( scalar $input->param('max_holds') );
 
     if ($branch eq "*") {
         Koha::CirculationRules->set_rules(
@@ -400,7 +417,7 @@ elsif ($op eq "set-branch-defaults") {
 }
 elsif ($op eq "add-branch-cat") {
     my $categorycode  = $input->param('categorycode');
-    my $patron_maxissueqty = strip_non_numeric($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');
@@ -459,15 +476,112 @@ 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 '';
+
+    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 '';
+
+    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 "*") {
             Koha::CirculationRules->set_rules(
@@ -522,16 +636,16 @@ elsif ($op eq "add-branch-item") {
 }
 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
+            # only do something for $lostreturn eq '*' if branch-specific
             Koha::CirculationRules->set_rules(
                 {
                     branchcode   => $branch,
                     rules        => {
-                        refund => undef
+                        lostreturn => undef
                     }
                 }
             );
@@ -541,17 +655,18 @@ elsif ( $op eq 'mod-refund-lost-item-fee-rule' ) {
             {
                 branchcode   => $branch,
                 rules        => {
-                    refund => $refund
+                    lostreturn => $lostreturn
                 }
             }
         );
     }
 }
 
-my $refundLostItemFeeRule = Koha::RefundLostItemFeeRules->find({ branchcode => ($branch eq '*') ? undef : $branch });
+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     => Koha::RefundLostItemFeeRules->_default_rule
+    defaultRefundRule     => $defaultLostItemFeeRule ? $defaultLostItemFeeRule->rule_value : 'refund'
 );
 
 my $patron_categories = Koha::Patron::Categories->search({}, { order_by => ['description'] });
@@ -566,7 +681,7 @@ my $definedbranch = $all_rules->count ? 1 : 0;
 my $rules = {};
 while ( my $r = $all_rules->next ) {
     $r = $r->unblessed;
-    $rules->{ $r->{categorycode} }->{ $r->{itemtype} }->{ $r->{rule_name} } = $r->{rule_value};
+    $rules->{ $r->{categorycode} // '' }->{ $r->{itemtype} // '' }->{ $r->{rule_name} } = $r->{rule_value};
 }
 
 $template->param(show_branch_cat_rule_form => 1);