View | Details | Raw Unified | Return to bug 18930
Collapse All | Expand All

(-)a/C4/Circulation.pm (-1 lines)
Lines 54-60 use Koha::Database; Link Here
54
use Koha::Libraries;
54
use Koha::Libraries;
55
use Koha::Account::Lines;
55
use Koha::Account::Lines;
56
use Koha::Holds;
56
use Koha::Holds;
57
use Koha::RefundLostItemFeeRule;
58
use Koha::RefundLostItemFeeRules;
57
use Koha::RefundLostItemFeeRules;
59
use Koha::Account::Lines;
58
use Koha::Account::Lines;
60
use Koha::Account::Offsets;
59
use Koha::Account::Offsets;
(-)a/Koha/RefundLostItemFeeRule.pm (-45 lines)
Lines 1-45 Link Here
1
package Koha::RefundLostItemFeeRule;
2
3
# Copyright Theke Solutions 2016
4
#
5
# This file is part of Koha.
6
#
7
# Koha is free software; you can redistribute it and/or modify it under the
8
# terms of the GNU General Public License as published by the Free Software
9
# Foundation; either version 3 of the License, or (at your option) any later
10
# version.
11
#
12
# Koha is distributed in the hope that it will be useful, but WITHOUT ANY
13
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14
# A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
15
#
16
# You should have received a copy of the GNU General Public License along
17
# with Koha; if not, write to the Free Software Foundation, Inc.,
18
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19
20
use Modern::Perl;
21
22
use Koha::Database;
23
use Koha::Exceptions;
24
25
use base qw(Koha::Object);
26
27
=head1 NAME
28
29
Koha::RefundLostItemFeeRule - Koha RefundLostItemFeeRule object class
30
31
=head1 API
32
33
=head2 Class Methods
34
35
=cut
36
37
=head3 type
38
39
=cut
40
41
sub _type {
42
    return 'RefundLostItemFeeRule';
43
}
44
45
1;
(-)a/Koha/RefundLostItemFeeRules.pm (-8 / +22 lines)
Lines 22-30 use Modern::Perl; Link Here
22
use Koha::Database;
22
use Koha::Database;
23
use Koha::Exceptions;
23
use Koha::Exceptions;
24
24
25
use Koha::RefundLostItemFeeRule;
25
use Koha::CirculationRule;
26
26
27
use base qw(Koha::Objects);
27
use base qw(Koha::CirculationRules);
28
28
29
=head1 NAME
29
=head1 NAME
30
30
Lines 41-47 Koha::RefundLostItemFeeRules - Koha RefundLostItemFeeRules object set class Link Here
41
=cut
41
=cut
42
42
43
sub _type {
43
sub _type {
44
    return 'RefundLostItemFeeRule';
44
    return 'CirculationRule';
45
}
45
}
46
46
47
=head3 object_class
47
=head3 object_class
Lines 49-55 sub _type { Link Here
49
=cut
49
=cut
50
50
51
sub object_class {
51
sub object_class {
52
    return 'Koha::RefundLostItemFeeRule';
52
    return 'Koha::CirculationRule';
53
}
53
}
54
54
55
=head3 should_refund
55
=head3 should_refund
Lines 84-93 sub _effective_branch_rule { Link Here
84
    my $self   = shift;
84
    my $self   = shift;
85
    my $branch = shift;
85
    my $branch = shift;
86
86
87
    my $specific_rule = $self->find({ branchcode => $branch });
87
    my $specific_rule = $self->search(
88
        {
89
            branchcode   => $branch,
90
            categorycode => undef,
91
            itemtype     => undef,
92
            rule_name    => 'refund',
93
        }
94
    )->next();
88
95
89
    return ( defined $specific_rule )
96
    return ( defined $specific_rule )
90
                ? $specific_rule->refund
97
                ? $specific_rule->rule_value
91
                : $self->_default_rule;
98
                : $self->_default_rule;
92
}
99
}
93
100
Lines 139-148 item fees on return. It defaults to 1 if no rule is defined. Link Here
139
sub _default_rule {
146
sub _default_rule {
140
147
141
    my $self = shift;
148
    my $self = shift;
142
    my $default_rule = $self->find({ branchcode => '*' });
149
    my $default_rule = $self->search(
150
        {
151
            branchcode   => '*',
152
            categorycode => undef,
153
            itemtype     => undef,
154
            rule_name    => 'refund',
155
        }
156
    )->next();
143
157
144
    return (defined $default_rule)
158
    return (defined $default_rule)
145
                ? $default_rule->refund
159
                ? $default_rule->rule_value
146
                : 1;
160
                : 1;
147
}
161
}
148
162
(-)a/Koha/Schema/Result/RefundLostItemFeeRule.pm (-66 lines)
Lines 1-66 Link Here
1
use utf8;
2
package Koha::Schema::Result::RefundLostItemFeeRule;
3
4
# Created by DBIx::Class::Schema::Loader
5
# DO NOT MODIFY THE FIRST PART OF THIS FILE
6
7
=head1 NAME
8
9
Koha::Schema::Result::RefundLostItemFeeRule
10
11
=cut
12
13
use strict;
14
use warnings;
15
16
use base 'DBIx::Class::Core';
17
18
=head1 TABLE: C<refund_lost_item_fee_rules>
19
20
=cut
21
22
__PACKAGE__->table("refund_lost_item_fee_rules");
23
24
=head1 ACCESSORS
25
26
=head2 branchcode
27
28
  data_type: 'varchar'
29
  default_value: (empty string)
30
  is_nullable: 0
31
  size: 10
32
33
=head2 refund
34
35
  data_type: 'tinyint'
36
  default_value: 0
37
  is_nullable: 0
38
39
=cut
40
41
__PACKAGE__->add_columns(
42
  "branchcode",
43
  { data_type => "varchar", default_value => "", is_nullable => 0, size => 10 },
44
  "refund",
45
  { data_type => "tinyint", default_value => 0, is_nullable => 0 },
46
);
47
48
=head1 PRIMARY KEY
49
50
=over 4
51
52
=item * L</branchcode>
53
54
=back
55
56
=cut
57
58
__PACKAGE__->set_primary_key("branchcode");
59
60
61
# Created by DBIx::Class::Schema::Loader v0.07042 @ 2016-05-31 02:45:35
62
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:K+2D3R+JxrovgvjdqA8xdw
63
64
65
# You can replace this text with custom code or comments, and it will be preserved on regeneration
66
1;
(-)a/admin/smart-rules.pl (-15 / +20 lines)
Lines 29-35 use Koha::Database; Link Here
29
use Koha::IssuingRule;
29
use Koha::IssuingRule;
30
use Koha::IssuingRules;
30
use Koha::IssuingRules;
31
use Koha::Logger;
31
use Koha::Logger;
32
use Koha::RefundLostItemFeeRule;
33
use Koha::RefundLostItemFeeRules;
32
use Koha::RefundLostItemFeeRules;
34
use Koha::Libraries;
33
use Koha::Libraries;
35
use Koha::CirculationRules;
34
use Koha::CirculationRules;
Lines 515-536 elsif ( $op eq 'mod-refund-lost-item-fee-rule' ) { Link Here
515
    if ( $refund eq '*' ) {
514
    if ( $refund eq '*' ) {
516
        if ( $branch ne '*' ) {
515
        if ( $branch ne '*' ) {
517
            # only do something for $refund eq '*' if branch-specific
516
            # only do something for $refund eq '*' if branch-specific
518
            eval {
517
            Koha::CirculationRules->set_rules(
519
                # Delete it so it picks the default
518
                {
520
                Koha::RefundLostItemFeeRules->find({
519
                    categorycode => undef,
521
                    branchcode => $branch
520
                    itemtype     => undef,
522
                })->delete;
521
                    branchcode   => $branch,
523
            };
522
                    rules        => {
523
                        refund => undef
524
                    }
525
                }
526
            );
524
        }
527
        }
525
    } else {
528
    } else {
526
        my $refundRule =
529
        Koha::CirculationRules->set_rules(
527
                Koha::RefundLostItemFeeRules->find({
530
            {
528
                    branchcode => $branch
531
                categorycode => undef,
529
                }) // Koha::RefundLostItemFeeRule->new;
532
                itemtype     => undef,
530
        $refundRule->set({
533
                branchcode   => $branch,
531
            branchcode => $branch,
534
                rules        => {
532
                refund => $refund
535
                    refund => $refund
533
        })->store;
536
                }
537
            }
538
        );
534
    }
539
    }
535
}
540
}
536
541
(-)a/installer/data/mysql/atomicupdate/bug_18930.perl (+14 lines)
Line 0 Link Here
1
$DBversion = 'XXX';  # will be replaced by the RM
2
if( CheckVersion( $DBversion ) ) {
3
    if ( column_exists( 'refund_lost_item_fee_rules', 'refund' ) ) {
4
        $dbh->do("
5
            INSERT INTO circulation_rules ( categorycode, branchcode, itemtype, rule_name, rule_value )
6
            SELECT NULL, branchcode, NULL, 'refund', refund
7
            FROM refund_lost_item_fee_rules
8
        ");
9
        $dbh->do("DROP TABLE refund_lost_item_fee_rules");
10
    }
11
12
    SetVersion( $DBversion );
13
    print "Upgrade to $DBversion done (Bug 18930 - Move lost item refund rules to circulation_rules table)\n";
14
}
(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/smart-rules.tt (-4 / +4 lines)
Lines 633-646 Link Here
633
                        <select name="refund">
633
                        <select name="refund">
634
                          [#% Default branch %#]
634
                          [#% Default branch %#]
635
                          [% IF ( current_branch == '*' ) %]
635
                          [% IF ( current_branch == '*' ) %]
636
                            [% IF ( ( not refundLostItemFeeRule.refund.defined ) || refundLostItemFeeRule.refund ) %]
636
                            [% IF ( refundLostItemFeeRule.rule_value ) %]
637
                            <option value="1" selected="selected">
637
                            <option value="1" selected="selected">
638
                            [% ELSE %]
638
                            [% ELSE %]
639
                            <option value="1">
639
                            <option value="1">
640
                            [% END %]
640
                            [% END %]
641
                                Yes
641
                                Yes
642
                            </option>
642
                            </option>
643
                            [% IF ( refundLostItemFeeRule.refund.defined && ( not refundLostItemFeeRule.refund ) ) %]
643
                            [% IF ( not refundLostItemFeeRule.rule_value ) %]
644
                            <option value="0" selected="selected">
644
                            <option value="0" selected="selected">
645
                            [% ELSE %]
645
                            [% ELSE %]
646
                            <option value="0">
646
                            <option value="0">
Lines 664-677 Link Here
664
                                <option value="1">Yes</option>
664
                                <option value="1">Yes</option>
665
                                <option value="0">No</option>
665
                                <option value="0">No</option>
666
                            [% ELSE %]
666
                            [% ELSE %]
667
                                [% IF ( refundLostItemFeeRule.refund ) %]
667
                                [% IF ( refundLostItemFeeRule.rule_value ) %]
668
                                <option value="1" selected="selected">
668
                                <option value="1" selected="selected">
669
                                [% ELSE %]
669
                                [% ELSE %]
670
                                <option value="1">
670
                                <option value="1">
671
                                [% END %]
671
                                [% END %]
672
                                    Yes
672
                                    Yes
673
                                </option>
673
                                </option>
674
                                [% IF ( not refundLostItemFeeRule.refund ) %]
674
                                [% IF ( not refundLostItemFeeRule.rule_value ) %]
675
                                <option value="0" selected="selected">
675
                                <option value="0" selected="selected">
676
                                [% ELSE %]
676
                                [% ELSE %]
677
                                <option value="0">
677
                                <option value="0">
(-)a/t/db_dependent/RefundLostItemFeeRule.t (-84 / +175 lines)
Lines 26-32 use Koha::Database; Link Here
26
26
27
BEGIN {
27
BEGIN {
28
    use_ok('Koha::Object');
28
    use_ok('Koha::Object');
29
    use_ok('Koha::RefundLostItemFeeRule');
29
    use_ok('Koha::CirculationRule');
30
    use_ok('Koha::RefundLostItemFeeRules');
30
    use_ok('Koha::RefundLostItemFeeRules');
31
}
31
}
32
32
Lines 41-72 subtest 'Koha::RefundLostItemFeeRule::delete() tests' => sub { Link Here
41
    $schema->storage->txn_begin;
41
    $schema->storage->txn_begin;
42
42
43
    # Clean the table
43
    # Clean the table
44
    $schema->resultset('RefundLostItemFeeRule')->search()->delete;
44
    $schema->resultset('CirculationRule')->search()->delete;
45
45
46
    my $generated_default_rule = $builder->build({
46
    my $generated_default_rule = $builder->build(
47
        source => 'RefundLostItemFeeRule',
47
        {
48
        value  => {
48
            source => 'CirculationRule',
49
            branchcode => '*'
49
            value  => {
50
                branchcode   => '*',
51
                categorycode => undef,
52
                itemtype     => undef,
53
                rule_name    => 'refund',
54
            }
50
        }
55
        }
51
    });
56
    );
52
    my $generated_other_rule = $builder->build({
57
    my $generated_other_rule = $builder->build(
53
        source => 'RefundLostItemFeeRule'
58
        {
54
    });
59
            source => 'CirculationRule',
55
60
            value  => {
56
    my $default_rule = Koha::RefundLostItemFeeRules->find({
61
                categorycode => undef,
57
            branchcode => '*' });
62
                itemtype     => undef,
63
                rule_name    => 'refund',
64
            }
65
        }
66
    );
67
68
    my $default_rule = Koha::CirculationRules->search(
69
        {
70
            branchcode   => '*',
71
            categorycode => undef,
72
            itemtype     => undef,
73
            rule_name    => 'refund',
74
        }
75
    )->next();
58
    ok( defined $default_rule, 'Default rule created' );
76
    ok( defined $default_rule, 'Default rule created' );
59
    ok( $default_rule->in_storage, 'Default rule actually in storage');
77
    ok( $default_rule->_result->in_storage, 'Default rule actually in storage');
60
78
61
    my $other_rule = Koha::RefundLostItemFeeRules->find({
79
    my $other_rule = Koha::CirculationRules->search(
62
            branchcode => $generated_other_rule->{ branchcode }
80
        {
63
    });
81
            branchcode   => $generated_other_rule->{branchcode},
82
            categorycode => undef,
83
            itemtype     => undef,
84
            rule_name    => 'refund',
85
        }
86
    )->next();
64
    ok( defined $other_rule, 'Other rule created' );
87
    ok( defined $other_rule, 'Other rule created' );
65
    ok( $other_rule->in_storage, 'Other rule actually in storage');
88
    ok( $other_rule->_result->in_storage, 'Other rule actually in storage');
66
89
67
    # deleting the regular rule
90
    # deleting the regular rule
68
    $other_rule->delete;
91
    $other_rule->delete;
69
    ok( !$other_rule->in_storage, 'Other rule deleted from storage' );
92
    ok( !$other_rule->_result->in_storage, 'Other rule deleted from storage' );
70
93
71
    # Rollback transaction
94
    # Rollback transaction
72
    $schema->storage->txn_rollback;
95
    $schema->storage->txn_rollback;
Lines 80-114 subtest 'Koha::RefundLostItemFeeRules::_default_rule() tests' => sub { Link Here
80
    $schema->storage->txn_begin;
103
    $schema->storage->txn_begin;
81
104
82
    # Clean the table
105
    # Clean the table
83
    $schema->resultset('RefundLostItemFeeRule')->search()->delete;
106
    $schema->resultset('CirculationRule')->search()->delete;
84
107
85
    my $generated_default_rule = $builder->build({
108
    my $generated_default_rule = $builder->build(
86
        source => 'RefundLostItemFeeRule',
109
        {
87
        value  => {
110
            source => 'CirculationRule',
88
            branchcode => '*',
111
            value  => {
89
            refund     => 1
112
                branchcode   => '*',
113
                categorycode => undef,
114
                itemtype     => undef,
115
                rule_name    => 'refund',
116
                rule_value   => 1,
117
            }
90
        }
118
        }
91
    });
119
    );
92
    my $generated_other_rule = $builder->build({
120
    my $generated_other_rule = $builder->build(
93
        source => 'RefundLostItemFeeRule'
121
        {
94
    });
122
            source => 'CirculationRule',
95
123
            value  => {
96
    my $default_rule = Koha::RefundLostItemFeeRules->find({
124
                categorycode => undef,
97
            branchcode => '*' });
125
                itemtype     => undef,
126
                rule_name    => 'refund',
127
            }
128
        }
129
    );
130
131
    my $default_rule = Koha::CirculationRules->search(
132
        {
133
            branchcode   => '*',
134
            categorycode => undef,
135
            itemtype     => undef,
136
            rule_name    => 'refund',
137
        }
138
    )->next();
98
    ok( defined $default_rule, 'Default rule created' );
139
    ok( defined $default_rule, 'Default rule created' );
99
    ok( $default_rule->in_storage, 'Default rule actually in storage');
140
    ok( $default_rule->_result->in_storage, 'Default rule actually in storage');
100
    ok( Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to refund' );
141
    is( Koha::RefundLostItemFeeRules->_default_rule, 1, 'Default rule is set to refund' );
101
142
102
    # Change default rule to "Don't refund"
143
    # Change default rule to "Don't refund"
103
    $default_rule->refund(0);
144
    $default_rule->rule_value(0);
104
    $default_rule->store;
145
    $default_rule->store;
105
    # Re-read from DB, to be sure
146
    # Re-read from DB, to be sure
106
    $default_rule = Koha::RefundLostItemFeeRules->find({
147
    $default_rule = Koha::CirculationRules->search(
107
            branchcode => '*' });
148
        {
149
            branchcode   => '*',
150
            categorycode => undef,
151
            itemtype     => undef,
152
            rule_name    => 'refund',
153
        }
154
    )->next();
108
    ok( !Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to not refund' );
155
    ok( !Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to not refund' );
109
156
110
    $default_rule->delete;
157
    $default_rule->delete;
111
    ok( !$default_rule->in_storage, 'Default rule effectively deleted from storage' );
158
    ok( !$default_rule->_result->in_storage, 'Default rule effectively deleted from storage' );
112
159
113
    ok( Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to refund if no default rule is present' );
160
    ok( Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to refund if no default rule is present' );
114
161
Lines 124-150 subtest 'Koha::RefundLostItemFeeRules::_effective_branch_rule() tests' => sub { Link Here
124
    $schema->storage->txn_begin;
171
    $schema->storage->txn_begin;
125
172
126
    # Clean the table
173
    # Clean the table
127
    $schema->resultset('RefundLostItemFeeRule')->search()->delete;
174
    $schema->resultset('CirculationRule')->search()->delete;
128
175
129
    my $default_rule = $builder->build({
176
    my $default_rule = $builder->build(
130
        source => 'RefundLostItemFeeRule',
177
        {
131
        value  => {
178
            source => 'CirculationRule',
132
            branchcode => '*',
179
            value  => {
133
            refund     => 1
180
                branchcode   => '*',
181
                categorycode => undef,
182
                itemtype     => undef,
183
                rule_name    => 'refund',
184
                rule_value   => 1,
185
            }
134
        }
186
        }
135
    });
187
    );
136
    my $specific_rule_false = $builder->build({
188
    my $specific_rule_false = $builder->build(
137
        source => 'RefundLostItemFeeRule',
189
        {
138
        value  => {
190
            source => 'CirculationRule',
139
            refund => 0
191
            value  => {
192
                categorycode => undef,
193
                itemtype     => undef,
194
                rule_name    => 'refund',
195
                rule_value   => 0,
196
            }
140
        }
197
        }
141
    });
198
    );
142
    my $specific_rule_true = $builder->build({
199
    my $specific_rule_true = $builder->build(
143
        source => 'RefundLostItemFeeRule',
200
        {
144
        value  => {
201
            source => 'CirculationRule',
145
            refund => 1
202
            value  => {
203
                categorycode => undef,
204
                itemtype     => undef,
205
                rule_name    => 'refund',
206
                rule_value   => 1,
207
            }
146
        }
208
        }
147
    });
209
    );
148
210
149
    is( Koha::RefundLostItemFeeRules->_effective_branch_rule( $specific_rule_true->{ branchcode } ),
211
    is( Koha::RefundLostItemFeeRules->_effective_branch_rule( $specific_rule_true->{ branchcode } ),
150
          1,'Specific rule is applied (true)');
212
          1,'Specific rule is applied (true)');
Lines 225-258 subtest 'Koha::RefundLostItemFeeRules::should_refund() tests' => sub { Link Here
225
287
226
    t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl', 'CheckinLibrary' );
288
    t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl', 'CheckinLibrary' );
227
289
228
    $schema->resultset('RefundLostItemFeeRule')->search()->delete;
290
    $schema->resultset('CirculationRule')->search()->delete;
229
291
230
    my $default_rule = $builder->build({
292
    my $default_rule = $builder->build(
231
        source => 'RefundLostItemFeeRule',
293
        {
232
        value  => {
294
            source => 'CirculationRule',
233
            branchcode => '*',
295
            value  => {
234
            refund     => 1
296
                branchcode   => '*',
297
                categorycode => undef,
298
                itemtype     => undef,
299
                rule_name    => 'refund',
300
                rule_value   => 1
301
            }
235
        }
302
        }
236
    });
303
    );
237
    my $specific_rule_false = $builder->build({
304
    my $specific_rule_false = $builder->build(
238
        source => 'RefundLostItemFeeRule',
305
        {
239
        value  => {
306
            source => 'CirculationRule',
240
            refund => 0
307
            value  => {
308
                categorycode => undef,
309
                itemtype     => undef,
310
                rule_name    => 'refund',
311
                rule_value   => 0
312
            }
241
        }
313
        }
242
    });
314
    );
243
    my $specific_rule_true = $builder->build({
315
    my $specific_rule_true = $builder->build(
244
        source => 'RefundLostItemFeeRule',
316
        {
245
        value  => {
317
            source => 'CirculationRule',
246
            refund => 1
318
            value  => {
319
                categorycode => undef,
320
                itemtype     => undef,
321
                rule_name    => 'refund',
322
                rule_value   => 1
323
            }
247
        }
324
        }
248
    });
325
    );
249
    # Make sure we have an unused branchcode
326
    # Make sure we have an unused branchcode
250
    my $specific_rule_dummy = $builder->build({
327
    my $specific_rule_dummy = $builder->build(
251
        source => 'RefundLostItemFeeRule'
328
        {
252
    });
329
            source => 'CirculationRule',
330
            value  => {
331
                categorycode => undef,
332
                itemtype     => undef,
333
                rule_name    => 'refund',
334
            }
335
        }
336
    );
253
    my $branch_without_rule = $specific_rule_dummy->{ branchcode };
337
    my $branch_without_rule = $specific_rule_dummy->{ branchcode };
254
    Koha::RefundLostItemFeeRules
338
    Koha::CirculationRules
255
        ->find({ branchcode => $branch_without_rule })
339
        ->search(
340
            {
341
                branchcode   => $branch_without_rule,
342
                categorycode => undef,
343
                itemtype     => undef,
344
                rule_name    => 'refund'
345
            }
346
          )
347
        ->next
256
        ->delete;
348
        ->delete;
257
349
258
    my $params = {
350
    my $params = {
Lines 271-277 subtest 'Koha::RefundLostItemFeeRules::should_refund() tests' => sub { Link Here
271
         1,'No rule for branch, global rule applied (true)');
363
         1,'No rule for branch, global rule applied (true)');
272
364
273
    # Change the default value just to try
365
    # Change the default value just to try
274
    Koha::RefundLostItemFeeRules->find({ branchcode => '*' })->refund(0)->store;
366
    Koha::CirculationRules->search({ branchcode => '*', rule_name => 'refund' })->next->rule_value(0)->store;
275
    t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl', 'ItemHoldingBranch' );
367
    t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl', 'ItemHoldingBranch' );
276
    is( Koha::RefundLostItemFeeRules->should_refund( $params ),
368
    is( Koha::RefundLostItemFeeRules->should_refund( $params ),
277
         0,'No rule for branch, global rule applied (false)');
369
         0,'No rule for branch, global rule applied (false)');
278
- 

Return to bug 18930