Attachment #91254 for bug #18930

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

Lines 54-60 use Koha::Database; Link Here

(-)a/C4/Circulation.pm (-1 lines)
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;




package Koha::RefundLostItemFeeRule;

# Copyright Theke Solutions 2016
#
# 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 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.
#
# 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.

use Modern::Perl;

use Koha::Database;
use Koha::Exceptions;

use base qw(Koha::Object);

=head1 NAME

Koha::RefundLostItemFeeRule - Koha RefundLostItemFeeRule object class

=head1 API

=head2 Class Methods

=cut

=head3 type

=cut

sub _type {
    return 'RefundLostItemFeeRule';
}

1;




use Koha::Database;
use Koha::Exceptions;

use Koha::CirculationRule;

use base qw(Koha::CirculationRules);

=head1 NAME


=cut

sub _type {
    return 'CirculationRule';
}

=head3 object_class

=cut

sub object_class {
    return 'Koha::CirculationRule';
}

=head3 should_refund

    my $self   = shift;
    my $branch = shift;

    my $specific_rule = $self->search(
        {
            branchcode   => $branch,
            categorycode => undef,
            itemtype     => undef,
            rule_name    => 'refund',
        }
    )->next();

    return ( defined $specific_rule )
                ? $specific_rule->rule_value
                : $self->_default_rule;
}


sub _default_rule {

    my $self = shift;
    my $default_rule = $self->search(
        {
            branchcode   => '*',
            categorycode => undef,
            itemtype     => undef,
            rule_name    => 'refund',
        }
    )->next();

    return (defined $default_rule)
                ? $default_rule->rule_value
                : 1;
}





use utf8;
package Koha::Schema::Result::RefundLostItemFeeRule;

# Created by DBIx::Class::Schema::Loader
# DO NOT MODIFY THE FIRST PART OF THIS FILE

=head1 NAME

Koha::Schema::Result::RefundLostItemFeeRule

=cut

use strict;
use warnings;

use base 'DBIx::Class::Core';

=head1 TABLE: C<refund_lost_item_fee_rules>

=cut

__PACKAGE__->table("refund_lost_item_fee_rules");

=head1 ACCESSORS

=head2 branchcode

  data_type: 'varchar'
  default_value: (empty string)
  is_nullable: 0
  size: 10

=head2 refund

  data_type: 'tinyint'
  default_value: 0
  is_nullable: 0

=cut

__PACKAGE__->add_columns(
  "branchcode",
  { data_type => "varchar", default_value => "", is_nullable => 0, size => 10 },
  "refund",
  { data_type => "tinyint", default_value => 0, is_nullable => 0 },
);

=head1 PRIMARY KEY

=over 4

=item * L</branchcode>

=back

=cut

__PACKAGE__->set_primary_key("branchcode");


# Created by DBIx::Class::Schema::Loader v0.07042 @ 2016-05-31 02:45:35
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:K+2D3R+JxrovgvjdqA8xdw


# You can replace this text with custom code or comments, and it will be preserved on regeneration
1;




use Koha::IssuingRule;
use Koha::IssuingRules;
use Koha::Logger;
use Koha::RefundLostItemFeeRule;
use Koha::RefundLostItemFeeRules;
use Koha::Libraries;
use Koha::CirculationRules;

    if ( $refund eq '*' ) {
        if ( $branch ne '*' ) {
            # only do something for $refund eq '*' if branch-specific
            Koha::CirculationRules->set_rules(
                {
                    categorycode => undef,
                    itemtype     => undef,
                    branchcode   => $branch,
                    rules        => {
                        refund => undef
                    }
                }
            );
        }
    } else {
        Koha::CirculationRules->set_rules(
            {
                categorycode => undef,
                itemtype     => undef,
                branchcode   => $branch,
                rules        => {
                    refund => $refund
                }
            }
        );
    }
}





$DBversion = 'XXX';  # will be replaced by the RM
if( CheckVersion( $DBversion ) ) {
    if ( column_exists( 'refund_lost_item_fee_rules', 'refund' ) ) {
        $dbh->do("
            INSERT INTO circulation_rules ( categorycode, branchcode, itemtype, rule_name, rule_value )
            SELECT NULL, branchcode, NULL, 'refund', refund
            FROM refund_lost_item_fee_rules
        ");
        $dbh->do("DROP TABLE refund_lost_item_fee_rules");
    }

    SetVersion( $DBversion );
    print "Upgrade to $DBversion done (Bug 18930 - Move lost item refund rules to circulation_rules table)\n";
}




                        <select name="refund">
                          [#% Default branch %#]
                          [% IF ( current_branch == '*' ) %]
                            [% IF ( refundLostItemFeeRule.rule_value ) %]
                            <option value="1" selected="selected">
                            [% ELSE %]
                            <option value="1">
                            [% END %]
                                Yes
                            </option>
                            [% IF ( not refundLostItemFeeRule.rule_value ) %]
                            <option value="0" selected="selected">
                            [% ELSE %]
                            <option value="0">

                                <option value="1">Yes</option>
                                <option value="0">No</option>
                            [% ELSE %]
                                [% IF ( refundLostItemFeeRule.rule_value ) %]
                                <option value="1" selected="selected">
                                [% ELSE %]
                                <option value="1">
                                [% END %]
                                    Yes
                                </option>
                                [% IF ( not refundLostItemFeeRule.rule_value ) %]
                                <option value="0" selected="selected">
                                [% ELSE %]
                                <option value="0">





BEGIN {
    use_ok('Koha::Object');
    use_ok('Koha::CirculationRule');
    use_ok('Koha::RefundLostItemFeeRules');
}


    $schema->storage->txn_begin;

    # Clean the table
    $schema->resultset('CirculationRule')->search()->delete;

    my $generated_default_rule = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                branchcode   => '*',
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
            }
        }
    );
    my $generated_other_rule = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
            }
        }
    );

    my $default_rule = Koha::CirculationRules->search(
        {
            branchcode   => '*',
            categorycode => undef,
            itemtype     => undef,
            rule_name    => 'refund',
        }
    )->next();
    ok( defined $default_rule, 'Default rule created' );
    ok( $default_rule->_result->in_storage, 'Default rule actually in storage');

    my $other_rule = Koha::CirculationRules->search(
        {
            branchcode   => $generated_other_rule->{branchcode},
            categorycode => undef,
            itemtype     => undef,
            rule_name    => 'refund',
        }
    )->next();
    ok( defined $other_rule, 'Other rule created' );
    ok( $other_rule->_result->in_storage, 'Other rule actually in storage');

    # deleting the regular rule
    $other_rule->delete;
    ok( !$other_rule->_result->in_storage, 'Other rule deleted from storage' );

    # Rollback transaction
    $schema->storage->txn_rollback;

    $schema->storage->txn_begin;

    # Clean the table
    $schema->resultset('CirculationRule')->search()->delete;

    my $generated_default_rule = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                branchcode   => '*',
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 1,
            }
        }
    );
    my $generated_other_rule = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
            }
        }
    );

    my $default_rule = Koha::CirculationRules->search(
        {
            branchcode   => '*',
            categorycode => undef,
            itemtype     => undef,
            rule_name    => 'refund',
        }
    )->next();
    ok( defined $default_rule, 'Default rule created' );
    ok( $default_rule->_result->in_storage, 'Default rule actually in storage');
    is( Koha::RefundLostItemFeeRules->_default_rule, 1, 'Default rule is set to refund' );

    # Change default rule to "Don't refund"
    $default_rule->rule_value(0);
    $default_rule->store;
    # Re-read from DB, to be sure
    $default_rule = Koha::CirculationRules->search(
        {
            branchcode   => '*',
            categorycode => undef,
            itemtype     => undef,
            rule_name    => 'refund',
        }
    )->next();
    ok( !Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to not refund' );

    $default_rule->delete;
    ok( !$default_rule->_result->in_storage, 'Default rule effectively deleted from storage' );

    ok( Koha::RefundLostItemFeeRules->_default_rule, 'Default rule is set to refund if no default rule is present' );


    $schema->storage->txn_begin;

    # Clean the table
    $schema->resultset('CirculationRule')->search()->delete;

    my $default_rule = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                branchcode   => '*',
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 1,
            }
        }
    );
    my $specific_rule_false = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 0,
            }
        }
    );
    my $specific_rule_true = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 1,
            }
        }
    );

    is( Koha::RefundLostItemFeeRules->_effective_branch_rule( $specific_rule_true->{ branchcode } ),
          1,'Specific rule is applied (true)');


    t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl', 'CheckinLibrary' );

    $schema->resultset('CirculationRule')->search()->delete;

    my $default_rule = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                branchcode   => '*',
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 1
            }
        }
    );
    my $specific_rule_false = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 0
            }
        }
    );
    my $specific_rule_true = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
                rule_value   => 1
            }
        }
    );
    # Make sure we have an unused branchcode
    my $specific_rule_dummy = $builder->build(
        {
            source => 'CirculationRule',
            value  => {
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund',
            }
        }
    );
    my $branch_without_rule = $specific_rule_dummy->{ branchcode };
    Koha::CirculationRules
        ->search(
            {
                branchcode   => $branch_without_rule,
                categorycode => undef,
                itemtype     => undef,
                rule_name    => 'refund'
            }
          )
        ->next
        ->delete;

    my $params = {

         1,'No rule for branch, global rule applied (true)');

    # Change the default value just to try
    Koha::CirculationRules->search({ branchcode => '*', rule_name => 'refund' })->next->rule_value(0)->store;
    t::lib::Mocks::mock_preference( 'RefundLostOnReturnControl', 'ItemHoldingBranch' );
    is( Koha::RefundLostItemFeeRules->should_refund( $params ),
         0,'No rule for branch, global rule applied (false)');
- 

Return to bug 18930

Lines 22-30 use Modern::Perl; Link Here

(-)a/Koha/RefundLostItemFeeRules.pm (-8 / +22 lines)
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

Lines 29-35 use Koha::Database; Link Here

(-)a/admin/smart-rules.pl (-15 / +20 lines)
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

Lines 633-646 Link Here

(-)a/koha-tmpl/intranet-tmpl/prog/en/modules/admin/smart-rules.tt (-4 / +4 lines)
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">

Lines 1-45 Link Here

(-)a/Koha/RefundLostItemFeeRule.pm (-45 lines)
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;

Lines 1-66 Link Here

(-)a/Koha/Schema/Result/RefundLostItemFeeRule.pm (-66 lines)
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;

Line 0 Link Here

(-)a/installer/data/mysql/atomicupdate/bug_18930.perl (+14 lines)
	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	}

Lines 26-32 use Koha::Database; Link Here

(-)a/t/db_dependent/RefundLostItemFeeRule.t (-84 / +175 lines)
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	-