Attachment #107525 for bug #25089

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




    },

    patron_maxissueqty => {
        scope => [ 'branchcode', 'categorycode', 'checkout_type' ],
    },
    patron_maxonsiteissueqty => {
        scope => [ 'branchcode', 'categorycode' ],

        scope => [ 'branchcode', 'categorycode', 'itemtype' ],
    },
    auto_renew => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    cap_fine_to_replacement_price => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    chargeperiod => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    chargeperiod_charge_at => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    fine => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    finedays => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    firstremind => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    hardduedate => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    hardduedatecompare => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    holds_per_day => {
        scope => [ 'branchcode', 'categorycode', 'itemtype' ],

        scope => [ 'branchcode', 'categorycode', 'itemtype' ],
    },
    issuelength => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    daysmode => {
        scope => [ 'branchcode', 'categorycode', 'itemtype' ],
    },
    lengthunit => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    maxissueqty => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    maxonsiteissueqty => {
        scope => [ 'branchcode', 'categorycode', 'itemtype' ],
    },
    maxsuspensiondays => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    no_auto_renewal_after => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    no_auto_renewal_after_hard_limit => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    norenewalbefore => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    onshelfholds => {
        scope => [ 'branchcode', 'categorycode', 'itemtype' ],

        scope => [ 'branchcode', 'categorycode', 'itemtype' ],
    },
    overduefinescap => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    renewalperiod => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    renewalsallowed => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    rentaldiscount => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    reservesallowed => {
        scope => [ 'branchcode', 'categorycode', 'itemtype' ],
    },
    suspension_chargeperiod => {
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    note => { # This is not really a rule. Maybe we will want to separate this later.
        scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
    },
    # Not included (deprecated?):
    #   * accountsent

    $params->{categorycode} //= undef;
    $params->{branchcode}   //= undef;
    $params->{itemtype}     //= undef;
    $params->{checkout_type} //= undef;

    my $rule_name    = $params->{rule_name};
    my $categorycode = $params->{categorycode};
    my $itemtype     = $params->{itemtype};
    my $branchcode   = $params->{branchcode};
    my $checkout_type = $params->{checkout_type};

    Koha::Exceptions::MissingParameter->throw(
        "Required parameter 'rule_name' missing")
      unless $rule_name;

    for my $v ( $branchcode, $categorycode, $itemtype, $checkout_type ) {
        $v = undef if $v and $v eq '*';
    }

    my $order_by = $params->{order_by}
      // { -desc => [ 'branchcode', 'checkout_type', 'categorycode', 'itemtype', ] };

    my $search_params;
    $search_params->{rule_name} = $rule_name;

    $search_params->{categorycode} = defined $categorycode ? [ $categorycode, undef ] : undef;
    $search_params->{itemtype}     = defined $itemtype     ? [ $itemtype, undef ] : undef;
    $search_params->{branchcode}   = defined $branchcode   ? [ $branchcode,   undef ] : undef;
    $search_params->{checkout_type} = defined $checkout_type ? [ $checkout_type, undef ] : undef;

    my $rule = $self->search(
        $search_params,

    my $rules        = $params->{rules};
    my $categorycode = $params->{categorycode};
    my $itemtype     = $params->{itemtype};
    my $checkout_type = $params->{checkout_type};
    my $branchcode   = $params->{branchcode};

    my $r;

                rule_name    => $rule,
                categorycode => $categorycode,
                itemtype     => $itemtype,
                checkout_type => $checkout_type,
                branchcode   => $branchcode,
            }
        );

        unless defined $kind_info;

    # Enforce scope; a rule should be set for its defined scope, no more, no less.
    foreach my $scope_level ( qw( branchcode categorycode itemtype checkout_type ) ) {
        if ( grep /$scope_level/, @{ $kind_info->{scope} } ) {
            croak "set_rule needs '$scope_level' to set '$params->{rule_name}'!"
                unless exists $params->{$scope_level};

    my $branchcode   = $params->{branchcode};
    my $categorycode = $params->{categorycode};
    my $itemtype     = $params->{itemtype};
    my $checkout_type = $params->{checkout_type};
    my $rule_name    = $params->{rule_name};
    my $rule_value   = $params->{rule_value};

    for my $v ( $branchcode, $categorycode, $itemtype, $checkout_type ) {
        $v = undef if $v and $v eq '*';
    }
    my $rule = $self->search(

            branchcode   => $branchcode,
            categorycode => $categorycode,
            itemtype     => $itemtype,
            checkout_type => $checkout_type,
        }
    )->next();


                    branchcode   => $branchcode,
                    categorycode => $categorycode,
                    itemtype     => $itemtype,
                    checkout_type => $checkout_type,
                    rule_name    => $rule_name,
                    rule_value   => $rule_value,
                }




use Test::More tests => 3;
use Test::Exception;

use Koha::Checkouts;
use Koha::CirculationRules;
use Koha::Database;



    $schema->storage->txn_begin;

    my $checkout_type = $Koha::Checkouts::type->{checkout};
    my $categorycode = $builder->build_object( { class => 'Koha::Patron::Categories' } )->categorycode;
    my $itemtype     = $builder->build_object( { class => 'Koha::ItemTypes' } )->itemtype;
    my $branchcode   = $builder->build_object( { class => 'Koha::Libraries' } )->branchcode;

            branchcode   => $branchcode,
            categorycode => $categorycode,
            itemtype     => $itemtype,
            checkout_type => $checkout_type,
            rule_name    => $rule_name,
        }
    );

            branchcode   => '*',
            categorycode => '*',
            itemtype     => '*',
            checkout_type => '*',
            rule_name    => $rule_name,
            rule_value   => $default_rule_value,
        }

            branchcode   => undef,
            categorycode => undef,
            itemtype     => undef,
            checkout_type => undef,
            rule_name    => $rule_name,
        }
    );

            branchcode   => '*',
            categorycode => '*',
            itemtype     => '*',
            checkout_type => '*',
            rule_name    => $rule_name,
        }
    );

            branchcode   => $branchcode_2,
            categorycode => '*',
            itemtype     => '*',
            checkout_type => '*',
            rule_name    => $rule_name,
        }
    );

            branchcode => $branchcode,
            categorycode => $categorycode,
            itemtype => $itemtype,
            checkout_type => $checkout_type,
        }, 'maxissueqty' );

        plan tests => 2**scalar @$order;

                branchcode => $branchcode,
                categorycode => $categorycode,
                itemtype => $itemtype,
                checkout_type => $checkout_type,
                rule_name => $rule_name,
            } );


    };

    my $our_branch_rules = Koha::CirculationRules->search({branchcode => $branchcode});
    is( $our_branch_rules->count, 8, "We added 16 rules");
    $our_branch_rules->delete;
    is( $our_branch_rules->count, 0, "We deleted 16 rules");

    $schema->storage->txn_rollback;
};

    plan tests => 1;

    subtest 'scope validation' => sub {
        plan tests => 7;

        $schema->storage->txn_begin;


            class => 'Koha::ItemTypes' } )->itemtype;
        my $branchcode   = $builder->build_object( {
            class => 'Koha::Libraries' } )->branchcode;
        my $checkout_type = $Koha::Checkouts::type->{checkout};

        my $rule;
        Koha::CirculationRules->delete;

            branchcode   => $branchcode,
            categorycode => $categorycode,
            itemtype     => $itemtype,
            checkout_type => $checkout_type,
            rules        => {
                refund              => 1,
                max_holds           => 9001,
                patron_maxissueqty  => 2,
                holdallowed         => 3,
                article_requests    => 4,
                maxissueqty         => 5,
            }
        } )}, 6, 'All rules added' );

        is( Koha::CirculationRules->get_effective_rule( {
            branchcode      => $branchcode,

        is( Koha::CirculationRules->get_effective_rule( {
            branchcode      => $branchcode,
            categorycode    => $categorycode,
            checkout_type   => $checkout_type,
            rule_name       => 'max_holds'
        } )->rule_value, 9001, 'Found rule patron_maxissueqty' );

        is( Koha::CirculationRules->get_effective_rule( {
            branchcode      => $branchcode,
            categorycode    => $categorycode,
            checkout_type   => $checkout_type,
            rule_name       => 'patron_maxissueqty'
        } )->rule_value, 2, 'Found rule patron_maxissueqty' );


            branchcode      => $branchcode,
            categorycode    => $categorycode,
            itemtype        => $itemtype,
            checkout_type   => $checkout_type,
            rule_name       => 'maxissueqty'
        } )->rule_value, 5, 'Found rule maxissueqty' );


    # We must maintain the order in order to keep the test valid. This should be
    # equal to Koha/CirculationRules.pm "order_by" of C<get_effective_rule> sub.
    # Let's explicitly define the order and fail test if we are missing a scope:
    my $order = [ 'branchcode', 'checkout_type', 'categorycode', 'itemtype' ];
    is( join(", ", sort keys %$scope),
       join(", ", sort @$order), 'Missing a scope!' ) if keys %$scope ne scalar @$order;

- 

Return to bug 25089

Lines 51-57 our $RULE_KINDS = { Link Here

(-)a/Koha/CirculationRules.pm (-27 / +35 lines)
51	},	51	},
52		52
53	patron_maxissueqty => {	53	patron_maxissueqty => {
54	scope => [ 'branchcode', 'categorycode' ],	54	scope => [ 'branchcode', 'categorycode', 'checkout_type' ],
55	},	55	},
56	patron_maxonsiteissueqty => {	56	patron_maxonsiteissueqty => {
57	scope => [ 'branchcode', 'categorycode' ],	57	scope => [ 'branchcode', 'categorycode' ],
Lines 74-104 our $RULE_KINDS = { Link Here
74	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	74	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
75	},	75	},
76	auto_renew => {	76	auto_renew => {
77	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	77	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
78	},	78	},
79	cap_fine_to_replacement_price => {	79	cap_fine_to_replacement_price => {
80	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	80	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
81	},	81	},
82	chargeperiod => {	82	chargeperiod => {
83	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	83	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
84	},	84	},
85	chargeperiod_charge_at => {	85	chargeperiod_charge_at => {
86	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	86	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
87	},	87	},
88	fine => {	88	fine => {
89	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	89	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
90	},	90	},
91	finedays => {	91	finedays => {
92	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	92	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
93	},	93	},
94	firstremind => {	94	firstremind => {
95	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	95	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
96	},	96	},
97	hardduedate => {	97	hardduedate => {
98	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	98	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
99	},	99	},
100	hardduedatecompare => {	100	hardduedatecompare => {
101	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	101	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
102	},	102	},
103	holds_per_day => {	103	holds_per_day => {
104	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	104	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
Lines 107-137 our $RULE_KINDS = { Link Here
107	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	107	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
108	},	108	},
109	issuelength => {	109	issuelength => {
110	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	110	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
111	},	111	},
112	daysmode => {	112	daysmode => {
113	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	113	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
114	},	114	},
115	lengthunit => {	115	lengthunit => {
116	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	116	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
117	},	117	},
118	maxissueqty => {	118	maxissueqty => {
119	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	119	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
120	},	120	},
121	maxonsiteissueqty => {	121	maxonsiteissueqty => {
122	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	122	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
123	},	123	},
124	maxsuspensiondays => {	124	maxsuspensiondays => {
125	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	125	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
126	},	126	},
127	no_auto_renewal_after => {	127	no_auto_renewal_after => {
128	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	128	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
129	},	129	},
130	no_auto_renewal_after_hard_limit => {	130	no_auto_renewal_after_hard_limit => {
131	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	131	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
132	},	132	},
133	norenewalbefore => {	133	norenewalbefore => {
134	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	134	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
135	},	135	},
136	onshelfholds => {	136	onshelfholds => {
137	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	137	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
Lines 140-164 our $RULE_KINDS = { Link Here
140	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	140	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
141	},	141	},
142	overduefinescap => {	142	overduefinescap => {
143	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	143	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
144	},	144	},
145	renewalperiod => {	145	renewalperiod => {
146	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	146	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
147	},	147	},
148	renewalsallowed => {	148	renewalsallowed => {
149	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	149	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
150	},	150	},
151	rentaldiscount => {	151	rentaldiscount => {
152	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	152	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
153	},	153	},
154	reservesallowed => {	154	reservesallowed => {
155	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	155	scope => [ 'branchcode', 'categorycode', 'itemtype' ],
156	},	156	},
157	suspension_chargeperiod => {	157	suspension_chargeperiod => {
158	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	158	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
159	},	159	},
160	note => { # This is not really a rule. Maybe we will want to separate this later.	160	note => { # This is not really a rule. Maybe we will want to separate this later.
161	scope => [ 'branchcode', 'categorycode', 'itemtype' ],	161	scope => [ 'branchcode', 'categorycode', 'itemtype', 'checkout_type' ],
162	},	162	},
163	# Not included (deprecated?):	163	# Not included (deprecated?):
164	# * accountsent	164	# * accountsent
Lines 180-201 sub get_effective_rule { Link Here
180	$params->{categorycode} //= undef;	180	$params->{categorycode} //= undef;
181	$params->{branchcode} //= undef;	181	$params->{branchcode} //= undef;
182	$params->{itemtype} //= undef;	182	$params->{itemtype} //= undef;
		183	$params->{checkout_type} //= undef;
183		184
184	my $rule_name = $params->{rule_name};	185	my $rule_name = $params->{rule_name};
185	my $categorycode = $params->{categorycode};	186	my $categorycode = $params->{categorycode};
186	my $itemtype = $params->{itemtype};	187	my $itemtype = $params->{itemtype};
187	my $branchcode = $params->{branchcode};	188	my $branchcode = $params->{branchcode};
		189	my $checkout_type = $params->{checkout_type};
188		190
189	Koha::Exceptions::MissingParameter->throw(	191	Koha::Exceptions::MissingParameter->throw(
190	"Required parameter 'rule_name' missing")	192	"Required parameter 'rule_name' missing")
191	unless $rule_name;	193	unless $rule_name;
192		194
193	for my $v ( $branchcode, $categorycode, $itemtype ) {	195	for my $v ( $branchcode, $categorycode, $itemtype, $checkout_type ) {
194	$v = undef if $v and $v eq '*';	196	$v = undef if $v and $v eq '*';
195	}	197	}
196		198
197	my $order_by = $params->{order_by}	199	my $order_by = $params->{order_by}
198	// { -desc => [ 'branchcode', 'categorycode', 'itemtype' ] };	200	// { -desc => [ 'branchcode', 'checkout_type', 'categorycode', 'itemtype', ] };
199		201
200	my $search_params;	202	my $search_params;
201	$search_params->{rule_name} = $rule_name;	203	$search_params->{rule_name} = $rule_name;
Lines 203-208 sub get_effective_rule { Link Here
203	$search_params->{categorycode} = defined $categorycode ? [ $categorycode, undef ] : undef;	205	$search_params->{categorycode} = defined $categorycode ? [ $categorycode, undef ] : undef;
204	$search_params->{itemtype} = defined $itemtype ? [ $itemtype, undef ] : undef;	206	$search_params->{itemtype} = defined $itemtype ? [ $itemtype, undef ] : undef;
205	$search_params->{branchcode} = defined $branchcode ? [ $branchcode, undef ] : undef;	207	$search_params->{branchcode} = defined $branchcode ? [ $branchcode, undef ] : undef;
		208	$search_params->{checkout_type} = defined $checkout_type ? [ $checkout_type, undef ] : undef;
206		209
207	my $rule = $self->search(	210	my $rule = $self->search(
208	$search_params,	211	$search_params,
Lines 225-230 sub get_effective_rules { Link Here
225	my $rules = $params->{rules};	228	my $rules = $params->{rules};
226	my $categorycode = $params->{categorycode};	229	my $categorycode = $params->{categorycode};
227	my $itemtype = $params->{itemtype};	230	my $itemtype = $params->{itemtype};
		231	my $checkout_type = $params->{checkout_type};
228	my $branchcode = $params->{branchcode};	232	my $branchcode = $params->{branchcode};
229		233
230	my $r;	234	my $r;
Lines 234-239 sub get_effective_rules { Link Here
234	rule_name => $rule,	238	rule_name => $rule,
235	categorycode => $categorycode,	239	categorycode => $categorycode,
236	itemtype => $itemtype,	240	itemtype => $itemtype,
		241	checkout_type => $checkout_type,
237	branchcode => $branchcode,	242	branchcode => $branchcode,
238	}	243	}
239	);	244	);
Lines 263-269 sub set_rule { Link Here
263	unless defined $kind_info;	268	unless defined $kind_info;
264		269
265	# Enforce scope; a rule should be set for its defined scope, no more, no less.	270	# Enforce scope; a rule should be set for its defined scope, no more, no less.
266	foreach my $scope_level ( qw( branchcode categorycode itemtype ) ) {	271	foreach my $scope_level ( qw( branchcode categorycode itemtype checkout_type ) ) {
267	if ( grep /$scope_level/, @{ $kind_info->{scope} } ) {	272	if ( grep /$scope_level/, @{ $kind_info->{scope} } ) {
268	croak "set_rule needs '$scope_level' to set '$params->{rule_name}'!"	273	croak "set_rule needs '$scope_level' to set '$params->{rule_name}'!"
269	unless exists $params->{$scope_level};	274	unless exists $params->{$scope_level};
Lines 276-285 sub set_rule { Link Here
276	my $branchcode = $params->{branchcode};	281	my $branchcode = $params->{branchcode};
277	my $categorycode = $params->{categorycode};	282	my $categorycode = $params->{categorycode};
278	my $itemtype = $params->{itemtype};	283	my $itemtype = $params->{itemtype};
		284	my $checkout_type = $params->{checkout_type};
279	my $rule_name = $params->{rule_name};	285	my $rule_name = $params->{rule_name};
280	my $rule_value = $params->{rule_value};	286	my $rule_value = $params->{rule_value};
281		287
282	for my $v ( $branchcode, $categorycode, $itemtype ) {	288	for my $v ( $branchcode, $categorycode, $itemtype, $checkout_type ) {
283	$v = undef if $v and $v eq '*';	289	$v = undef if $v and $v eq '*';
284	}	290	}
285	my $rule = $self->search(	291	my $rule = $self->search(
Lines 288-293 sub set_rule { Link Here
288	branchcode => $branchcode,	294	branchcode => $branchcode,
289	categorycode => $categorycode,	295	categorycode => $categorycode,
290	itemtype => $itemtype,	296	itemtype => $itemtype,
		297	checkout_type => $checkout_type,
291	}	298	}
292	)->next();	299	)->next();
293		300
Lines 307-312 sub set_rule { Link Here
307	branchcode => $branchcode,	314	branchcode => $branchcode,
308	categorycode => $categorycode,	315	categorycode => $categorycode,
309	itemtype => $itemtype,	316	itemtype => $itemtype,
		317	checkout_type => $checkout_type,
310	rule_name => $rule_name,	318	rule_name => $rule_name,
311	rule_value => $rule_value,	319	rule_value => $rule_value,
312	}	320	}

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

(-)a/t/db_dependent/Koha/CirculationRules.t (-6 / +26 lines)
22	use Test::More tests => 3;	22	use Test::More tests => 3;
23	use Test::Exception;	23	use Test::Exception;
24		24
		25	use Koha::Checkouts;
25	use Koha::CirculationRules;	26	use Koha::CirculationRules;
26	use Koha::Database;	27	use Koha::Database;
27		28
Lines 36-41 subtest 'set_rule + get_effective_rule' => sub { Link Here
36		37
37	$schema->storage->txn_begin;	38	$schema->storage->txn_begin;
38		39
		40	my $checkout_type = $Koha::Checkouts::type->{checkout};
39	my $categorycode = $builder->build_object( { class => 'Koha::Patron::Categories' } )->categorycode;	41	my $categorycode = $builder->build_object( { class => 'Koha::Patron::Categories' } )->categorycode;
40	my $itemtype = $builder->build_object( { class => 'Koha::ItemTypes' } )->itemtype;	42	my $itemtype = $builder->build_object( { class => 'Koha::ItemTypes' } )->itemtype;
41	my $branchcode = $builder->build_object( { class => 'Koha::Libraries' } )->branchcode;	43	my $branchcode = $builder->build_object( { class => 'Koha::Libraries' } )->branchcode;
Lines 55-60 subtest 'set_rule + get_effective_rule' => sub { Link Here
55	branchcode => $branchcode,	57	branchcode => $branchcode,
56	categorycode => $categorycode,	58	categorycode => $categorycode,
57	itemtype => $itemtype,	59	itemtype => $itemtype,
		60	checkout_type => $checkout_type,
58	rule_name => $rule_name,	61	rule_name => $rule_name,
59	}	62	}
60	);	63	);
Lines 65-70 subtest 'set_rule + get_effective_rule' => sub { Link Here
65	branchcode => '*',	68	branchcode => '*',
66	categorycode => '*',	69	categorycode => '*',
67	itemtype => '*',	70	itemtype => '*',
		71	checkout_type => '*',
68	rule_name => $rule_name,	72	rule_name => $rule_name,
69	rule_value => $default_rule_value,	73	rule_value => $default_rule_value,
70	}	74	}
Lines 75-80 subtest 'set_rule + get_effective_rule' => sub { Link Here
75	branchcode => undef,	79	branchcode => undef,
76	categorycode => undef,	80	categorycode => undef,
77	itemtype => undef,	81	itemtype => undef,
		82	checkout_type => undef,
78	rule_name => $rule_name,	83	rule_name => $rule_name,
79	}	84	}
80	);	85	);
Lines 84-89 subtest 'set_rule + get_effective_rule' => sub { Link Here
84	branchcode => '*',	89	branchcode => '*',
85	categorycode => '*',	90	categorycode => '*',
86	itemtype => '*',	91	itemtype => '*',
		92	checkout_type => '*',
87	rule_name => $rule_name,	93	rule_name => $rule_name,
88	}	94	}
89	);	95	);
Lines 95-100 subtest 'set_rule + get_effective_rule' => sub { Link Here
95	branchcode => $branchcode_2,	101	branchcode => $branchcode_2,
96	categorycode => '*',	102	categorycode => '*',
97	itemtype => '*',	103	itemtype => '*',
		104	checkout_type => '*',
98	rule_name => $rule_name,	105	rule_name => $rule_name,
99	}	106	}
100	);	107	);
Lines 107-112 subtest 'set_rule + get_effective_rule' => sub { Link Here
107	branchcode => $branchcode,	114	branchcode => $branchcode,
108	categorycode => $categorycode,	115	categorycode => $categorycode,
109	itemtype => $itemtype,	116	itemtype => $itemtype,
		117	checkout_type => $checkout_type,
110	}, 'maxissueqty' );	118	}, 'maxissueqty' );
111		119
112	plan tests => 2**scalar @$order;	120	plan tests => 2**scalar @$order;
Lines 122-127 subtest 'set_rule + get_effective_rule' => sub { Link Here
122	branchcode => $branchcode,	130	branchcode => $branchcode,
123	categorycode => $categorycode,	131	categorycode => $categorycode,
124	itemtype => $itemtype,	132	itemtype => $itemtype,
		133	checkout_type => $checkout_type,
125	rule_name => $rule_name,	134	rule_name => $rule_name,
126	} );	135	} );
127		136
Lines 137-145 subtest 'set_rule + get_effective_rule' => sub { Link Here
137	};	146	};
138		147
139	my $our_branch_rules = Koha::CirculationRules->search({branchcode => $branchcode});	148	my $our_branch_rules = Koha::CirculationRules->search({branchcode => $branchcode});
140	is( $our_branch_rules->count, 4, "We added 8 rules");	149	is( $our_branch_rules->count, 8, "We added 16 rules");
141	$our_branch_rules->delete;	150	$our_branch_rules->delete;
142	is( $our_branch_rules->count, 0, "We deleted 8 rules");	151	is( $our_branch_rules->count, 0, "We deleted 16 rules");
143		152
144	$schema->storage->txn_rollback;	153	$schema->storage->txn_rollback;
145	};	154	};
Lines 271-277 subtest 'set_rules() tests' => sub { Link Here
271	plan tests => 1;	280	plan tests => 1;
272		281
273	subtest 'scope validation' => sub {	282	subtest 'scope validation' => sub {
274	plan tests => 6;	283	plan tests => 7;
275		284
276	$schema->storage->txn_begin;	285	$schema->storage->txn_begin;
277		286
Lines 281-286 subtest 'set_rules() tests' => sub { Link Here
281	class => 'Koha::ItemTypes' } )->itemtype;	290	class => 'Koha::ItemTypes' } )->itemtype;
282	my $branchcode = $builder->build_object( {	291	my $branchcode = $builder->build_object( {
283	class => 'Koha::Libraries' } )->branchcode;	292	class => 'Koha::Libraries' } )->branchcode;
		293	my $checkout_type = $Koha::Checkouts::type->{checkout};
284		294
285	my $rule;	295	my $rule;
286	Koha::CirculationRules->delete;	296	Koha::CirculationRules->delete;
Lines 289-302 subtest 'set_rules() tests' => sub { Link Here
289	branchcode => $branchcode,	299	branchcode => $branchcode,
290	categorycode => $categorycode,	300	categorycode => $categorycode,
291	itemtype => $itemtype,	301	itemtype => $itemtype,
		302	checkout_type => $checkout_type,
292	rules => {	303	rules => {
293	refund => 1,	304	refund => 1,
		305	max_holds => 9001,
294	patron_maxissueqty => 2,	306	patron_maxissueqty => 2,
295	holdallowed => 3,	307	holdallowed => 3,
296	article_requests => 4,	308	article_requests => 4,
297	maxissueqty => 5,	309	maxissueqty => 5,
298	}	310	}
299	} )}, 5, 'All rules added' );	311	} )}, 6, 'All rules added' );
300		312
301	is( Koha::CirculationRules->get_effective_rule( {	313	is( Koha::CirculationRules->get_effective_rule( {
302	branchcode => $branchcode,	314	branchcode => $branchcode,
Lines 306-311 subtest 'set_rules() tests' => sub { Link Here
306	is( Koha::CirculationRules->get_effective_rule( {	318	is( Koha::CirculationRules->get_effective_rule( {
307	branchcode => $branchcode,	319	branchcode => $branchcode,
308	categorycode => $categorycode,	320	categorycode => $categorycode,
		321	checkout_type => $checkout_type,
		322	rule_name => 'max_holds'
		323	} )->rule_value, 9001, 'Found rule patron_maxissueqty' );
		324
		325	is( Koha::CirculationRules->get_effective_rule( {
		326	branchcode => $branchcode,
		327	categorycode => $categorycode,
		328	checkout_type => $checkout_type,
309	rule_name => 'patron_maxissueqty'	329	rule_name => 'patron_maxissueqty'
310	} )->rule_value, 2, 'Found rule patron_maxissueqty' );	330	} )->rule_value, 2, 'Found rule patron_maxissueqty' );
311		331
Lines 326-331 subtest 'set_rules() tests' => sub { Link Here
326	branchcode => $branchcode,	346	branchcode => $branchcode,
327	categorycode => $categorycode,	347	categorycode => $categorycode,
328	itemtype => $itemtype,	348	itemtype => $itemtype,
		349	checkout_type => $checkout_type,
329	rule_name => 'maxissueqty'	350	rule_name => 'maxissueqty'
330	} )->rule_value, 5, 'Found rule maxissueqty' );	351	} )->rule_value, 5, 'Found rule maxissueqty' );
331		352
Lines 361-367 sub prepare_tests_for_rule_scope_combinations { Link Here
361	# We must maintain the order in order to keep the test valid. This should be	382	# We must maintain the order in order to keep the test valid. This should be
362	# equal to Koha/CirculationRules.pm "order_by" of C<get_effective_rule> sub.	383	# equal to Koha/CirculationRules.pm "order_by" of C<get_effective_rule> sub.
363	# Let's explicitly define the order and fail test if we are missing a scope:	384	# Let's explicitly define the order and fail test if we are missing a scope:
364	my $order = [ 'branchcode', 'categorycode', 'itemtype' ];	385	my $order = [ 'branchcode', 'checkout_type', 'categorycode', 'itemtype' ];
365	is( join(", ", sort keys %$scope),	386	is( join(", ", sort keys %$scope),
366	join(", ", sort @$order), 'Missing a scope!' ) if keys %$scope ne scalar @$order;	387	join(", ", sort @$order), 'Missing a scope!' ) if keys %$scope ne scalar @$order;
367		388
368	-