use strict;
#use warnings; FIXME - Bug 2505
-use C4::Context;
+
+use C4::Accounts;
use C4::Biblio;
-use C4::Members;
-use C4::Items;
use C4::Circulation;
-use C4::Accounts;
-
-# for _koha_notify_reserve
-use C4::Members::Messaging;
-use C4::Members qw();
+use C4::Context;
+use C4::Items;
use C4::Letters;
use C4::Log;
-
+use C4::Members::Messaging;
+use C4::Members;
+use Koha::Account::Lines;
use Koha::Biblios;
-use Koha::DateUtils;
use Koha::Calendar;
+use Koha::CirculationRules;
use Koha::Database;
+use Koha::DateUtils;
use Koha::Hold;
-use Koha::Old::Hold;
use Koha::Holds;
-use Koha::Libraries;
use Koha::IssuingRules;
-use Koha::Items;
use Koha::ItemTypes;
+use Koha::Items;
+use Koha::Libraries;
+use Koha::Old::Hold;
use Koha::Patrons;
-use List::MoreUtils qw( firstidx any );
use Carp;
use Data::Dumper;
+use List::MoreUtils qw( firstidx any );
use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
push (@itemnumbers, @hostitems);
}
- my $canReserve;
+ my $canReserve = { status => '' };
foreach my $itemnumber (@itemnumbers) {
$canReserve = CanItemBeReserved( $borrowernumber, $itemnumber, $pickup_branchcode );
return { status => 'OK' } if $canReserve->{status} eq 'OK';
{ status => notReservable }, if holds on this item are not allowed
{ status => libraryNotFound }, if given branchcode is not an existing library
{ status => libraryNotPickupLocation }, if given branchcode is not configured to be a pickup location
+ { status => cannotBeTransferred }, if branch transfer limit applies on given item and branchcode
=cut
my $ruleitemtype; # itemtype of the matching issuing rule
my $allowedreserves = 0; # Total number of holds allowed across all records
my $holds_per_record = 1; # Total number of holds allowed for this one given record
+ my $holds_per_day; # Default to unlimited
# we retrieve borrowers and items informations #
# item->{itype} will come for biblioitems if necessery
- my $item = GetItem($itemnumber);
- my $biblio = Koha::Biblios->find( $item->{biblionumber} );
+ my $item = Koha::Items->find($itemnumber);
+ my $biblio = $item->biblio;
my $patron = Koha::Patrons->find( $borrowernumber );
my $borrower = $patron->unblessed;
# If an item is damaged and we don't allow holds on damaged items, we can stop right here
return { status =>'damaged' }
- if ( $item->{damaged}
+ if ( $item->damaged
&& !C4::Context->preference('AllowHoldsOnDamagedItems') );
# Check for the age restriction
if ( $controlbranch eq "ItemHomeLibrary" ) {
$branchfield = "items.homebranch";
- $branchcode = $item->{homebranch};
+ $branchcode = $item->homebranch;
}
elsif ( $controlbranch eq "PatronLibrary" ) {
$branchfield = "borrowers.branchcode";
}
# we retrieve rights
- if ( my $rights = GetHoldRule( $borrower->{'categorycode'}, $item->{'itype'}, $branchcode ) ) {
+ if ( my $rights = GetHoldRule( $borrower->{'categorycode'}, $item->effective_itemtype, $branchcode ) ) {
$ruleitemtype = $rights->{itemtype};
$allowedreserves = $rights->{reservesallowed};
$holds_per_record = $rights->{holds_per_record};
+ $holds_per_day = $rights->{holds_per_day};
}
else {
$ruleitemtype = '*';
}
- $item = Koha::Items->find( $itemnumber );
my $holds = Koha::Holds->search(
{
borrowernumber => $borrowernumber,
return { status => "tooManyHoldsForThisRecord", limit => $holds_per_record };
}
+ my $today_holds = Koha::Holds->search({
+ borrowernumber => $borrowernumber,
+ reservedate => dt_from_string->date
+ });
+
+ if ( defined $holds_per_day &&
+ ( ( $holds_per_day > 0 && $today_holds->count() >= $holds_per_day )
+ or ( $holds_per_day == 0 ) )
+ ) {
+ return { status => 'tooManyReservesToday', limit => $holds_per_day };
+ }
+
# we retrieve count
$querycount .= "AND $branchfield = ?";
}
# Now we need to check hold limits by patron category
- my $schema = Koha::Database->new()->schema();
- my $rule = $schema->resultset('BranchBorrowerCircRule')->find(
+ my $rule = Koha::CirculationRules->get_effective_rule(
{
- branchcode => $branchcode,
categorycode => $borrower->{categorycode},
+ branchcode => $branchcode,
+ rule_name => 'max_holds',
}
);
- $rule ||= $schema->resultset('DefaultBorrowerCircRule')->find(
- {
- categorycode => $borrower->{categorycode}
- }
- );
- if ( $rule && defined $rule->max_holds ) {
+ if ( $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
my $total_holds_count = Koha::Holds->search(
{
borrowernumber => $borrower->{borrowernumber}
}
)->count();
- return { status => 'tooManyReserves', limit => $rule->max_holds } if $total_holds_count >= $rule->max_holds;
+ return { status => 'tooManyReserves', limit => $rule->rule_value} if $total_holds_count >= $rule->rule_value;
}
my $circ_control_branch =
C4::Circulation::_GetCircControlBranch( $item->unblessed(), $borrower );
my $branchitemrule =
- C4::Circulation::GetBranchItemRule( $circ_control_branch, $item->itype );
+ C4::Circulation::GetBranchItemRule( $circ_control_branch, $item->itype ); # FIXME Should not be item->effective_itemtype?
if ( $branchitemrule->{holdallowed} == 0 ) {
return { status => 'notReservable' };
if ( C4::Context->preference('IndependentBranches')
and !C4::Context->preference('canreservefromotherbranches') )
{
- my $itembranch = $item->homebranch;
- if ( $itembranch ne $borrower->{branchcode} ) {
+ if ( $item->homebranch ne $borrower->{branchcode} ) {
return { status => 'cannotReserveFromOtherBranches' };
}
}
my $destination = Koha::Libraries->find({
branchcode => $pickup_branchcode,
});
+
unless ($destination) {
return { status => 'libraryNotFound' };
}
unless ($destination->pickup_location) {
return { status => 'libraryNotPickupLocation' };
}
+ unless ($item->can_be_transferred({ to => $destination })) {
+ return { status => 'cannotBeTransferred' };
+ }
}
return { status => 'OK' };
my $nextreservinfo;
my ( undef, $checkreserves, undef ) = CheckReserves($itemnumber);
if ($checkreserves) {
- my $iteminfo = GetItem($itemnumber);
- if ( $iteminfo->{'holdingbranch'} ne $checkreserves->{'branchcode'} ) {
+ my $item = Koha::Items->find($itemnumber);
+ if ( $item->holdingbranch ne $checkreserves->{'branchcode'} ) {
$messages->{'transfert'} = $checkreserves->{'branchcode'};
#minus priorities of others reservs
ModReserveMinusPriority(
#launch the subroutine dotransfer
C4::Items::ModItemTransfer(
$itemnumber,
- $iteminfo->{'holdingbranch'},
+ $item->holdingbranch,
$checkreserves->{'branchcode'}
),
;
sub ChargeReserveFee {
my ( $borrowernumber, $fee, $title ) = @_;
- return if !$fee || $fee==0; # the last test is needed to include 0.00
- my $accquery = qq{
-INSERT INTO accountlines ( borrowernumber, accountno, date, amount, description, accounttype, amountoutstanding ) VALUES (?, ?, NOW(), ?, ?, 'Res', ?)
- };
- my $dbh = C4::Context->dbh;
- my $nextacctno = &getnextacctno( $borrowernumber );
- $dbh->do( $accquery, undef, ( $borrowernumber, $nextacctno, $fee, "Reserve Charge - $title", $fee ) );
+ return if !$fee || $fee == 0; # the last test is needed to include 0.00
+ Koha::Account->new( { patron_id => $borrowernumber } )->add_debit(
+ {
+ amount => $fee,
+ description => "Reserve Charge - " . $title,
+ note => undef,
+ user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : 0,
+ library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
+ sip => undef,
+ invoice_type => undef,
+ type => 'reserve',
+ item_id => undef
+ }
+ );
}
=head2 GetReserveFee
}
} else {
my $patron;
- my $iteminfo;
+ my $item;
my $local_hold_match;
if ($LocalHoldsPriority) {
$patron = Koha::Patrons->find( $res->{borrowernumber} );
- $iteminfo = C4::Items::GetItem($itemnumber);
+ $item = Koha::Items->find($itemnumber);
my $local_holds_priority_item_branchcode =
- $iteminfo->{$LocalHoldsPriorityItemControl};
+ $item->$LocalHoldsPriorityItemControl;
my $local_holds_priority_patron_branchcode =
( $LocalHoldsPriorityPatronControl eq 'PickupLibrary' )
? $res->{branchcode}
# See if this item is more important than what we've got so far
if ( ( $res->{'priority'} && $res->{'priority'} < $priority ) || $local_hold_match ) {
- $iteminfo ||= C4::Items::GetItem($itemnumber);
- next if $res->{itemtype} && $res->{itemtype} ne _get_itype( $iteminfo );
+ $item ||= Koha::Items->find($itemnumber);
+ next if $res->{itemtype} && $res->{itemtype} ne $item->effective_itemtype;
$patron ||= Koha::Patrons->find( $res->{borrowernumber} );
- my $branch = GetReservesControlBranch( $iteminfo, $patron->unblessed );
- my $branchitemrule = C4::Circulation::GetBranchItemRule($branch,$iteminfo->{'itype'});
+ my $branch = GetReservesControlBranch( $item->unblessed, $patron->unblessed );
+ my $branchitemrule = C4::Circulation::GetBranchItemRule($branch,$item->effective_itemtype);
next if ($branchitemrule->{'holdallowed'} == 0);
next if (($branchitemrule->{'holdallowed'} == 1) && ($branch ne $patron->branchcode));
- next if ( ($branchitemrule->{hold_fulfillment_policy} ne 'any') && ($res->{branchcode} ne $iteminfo->{ $branchitemrule->{hold_fulfillment_policy} }) );
+ my $hold_fulfillment_policy = $branchitemrule->{hold_fulfillment_policy};
+ next if ( ($branchitemrule->{hold_fulfillment_policy} ne 'any') && ($res->{branchcode} ne $item->$hold_fulfillment_policy) );
+ next unless $item->can_be_transferred( { to => scalar Koha::Libraries->find( $res->{branchcode} ) } );
$priority = $res->{'priority'};
$highest = $res;
last if $local_hold_match;
my @holds = Koha::Holds->search( { suspend_until => { '<=' => $today->ymd() } } );
- map { $_->suspend(0)->suspend_until(undef)->store() } @holds;
+ map { $_->resume() } @holds;
}
=head2 ModReserve
=head2 IsAvailableForItemLevelRequest
- my $is_available = IsAvailableForItemLevelRequest($item_record,$borrower_record);
+ my $is_available = IsAvailableForItemLevelRequest( $item_record, $borrower_record, $pickup_branchcode );
Checks whether a given item record is available for an
item-level hold request. An item is available if
sub IsAvailableForItemLevelRequest {
my $item = shift;
my $borrower = shift;
+ my $pickup_branchcode = shift;
my $dbh = C4::Context->dbh;
# must check the notforloan setting of the itemtype
my $on_shelf_holds = Koha::IssuingRules->get_onshelfholds_policy( { item => $item_object, patron => $patron } );
+ if ($pickup_branchcode) {
+ my $destination = Koha::Libraries->find($pickup_branchcode);
+ return 0 unless $destination;
+ return 0 unless $destination->pickup_location;
+ return 0 unless $item_object->can_be_transferred( { to => $destination } );
+ }
+
if ( $on_shelf_holds == 1 ) {
return 1;
} elsif ( $on_shelf_holds == 2 ) {
=head2 AlterPriority
- AlterPriority( $where, $reserve_id );
+ AlterPriority( $where, $reserve_id, $prev_priority, $next_priority, $first_priority, $last_priority );
This function changes a reserve's priority up, down, to the top, or to the bottom.
Input: $where is 'up', 'down', 'top' or 'bottom'. Biblionumber, Date reserve was placed
=cut
sub AlterPriority {
- my ( $where, $reserve_id ) = @_;
+ my ( $where, $reserve_id, $prev_priority, $next_priority, $first_priority, $last_priority ) = @_;
my $hold = Koha::Holds->find( $reserve_id );
return unless $hold;
return;
}
- if ( $where eq 'up' || $where eq 'down' ) {
-
- my $priority = $hold->priority;
- $priority = $where eq 'up' ? $priority - 1 : $priority + 1;
- _FixPriority({ reserve_id => $reserve_id, rank => $priority })
-
+ if ( $where eq 'up' ) {
+ return unless $prev_priority;
+ _FixPriority({ reserve_id => $reserve_id, rank => $prev_priority })
+ } elsif ( $where eq 'down' ) {
+ return unless $next_priority;
+ _FixPriority({ reserve_id => $reserve_id, rank => $next_priority })
} elsif ( $where eq 'top' ) {
-
- _FixPriority({ reserve_id => $reserve_id, rank => '1' })
-
+ _FixPriority({ reserve_id => $reserve_id, rank => $first_priority })
} elsif ( $where eq 'bottom' ) {
-
- _FixPriority({ reserve_id => $reserve_id, rank => '999999' });
-
+ _FixPriority({ reserve_id => $reserve_id, rank => $last_priority });
}
+
# FIXME Should return the new priority
}
my $sth = $dbh->prepare(
q{
- SELECT categorycode, itemtype, branchcode, reservesallowed, holds_per_record
+ SELECT categorycode, itemtype, branchcode, reservesallowed, holds_per_record, holds_per_day
FROM issuingrules
WHERE (categorycode in (?,'*') )
AND (itemtype IN (?,'*'))
projects / koha.git / blobdiff