# along with Koha; if not, see <http://www.gnu.org/licenses>.
-use strict;
-#use warnings; FIXME - Bug 2505
+use Modern::Perl;
use C4::Accounts;
use C4::Biblio;
# if we have an item selectionned, and the pickup branch is the same as the holdingbranch
# of the document, we force the value $priority and $found .
if ( $checkitem and not C4::Context->preference('ReservesNeedReturns') ) {
- $priority = 0;
my $item = Koha::Items->find( $checkitem ); # FIXME Prevent bad calls
- if ( $item->holdingbranch eq $branch ) {
+
+ if (
+ # If item is already checked out, it cannot be set waiting
+ !$item->onloan
+
+ # The item can't be waiting if it needs a transfer
+ && $item->holdingbranch eq $branch
+
+ # Similarly, if in transit it can't be waiting
+ && !$item->get_transfer
+
+ # If we can't hold damaged items, and it is damaged, it can't be waiting
+ && ( $item->damaged && C4::Context->preference('AllowHoldsOnDamagedItems') || !$item->damaged )
+
+ # Lastly, if this already has holds, we shouldn't make it waiting for the new hold
+ && !$item->current_holds->count )
+ {
+ $priority = 0;
$found = 'W';
}
}
my $waitingdate;
# If the reserv had the waiting status, we had the value of the resdate
- if ( $found eq 'W' ) {
+ if ( $found && $found eq 'W' ) {
$waitingdate = $resdate;
}
waitingdate => $waitingdate,
expirationdate => $expdate,
itemtype => $itemtype,
+ item_level_hold => $checkitem ? 1 : 0,
}
)->store();
- $hold->set_waiting() if $found eq 'W';
+ $hold->set_waiting() if $found && $found eq 'W';
logaction( 'HOLDS', 'CREATE', $hold->id, Dumper($hold->unblessed) )
if C4::Context->preference('HoldsLog');
{ status => ageRestricted }, if the Item is age restricted for this borrower.
{ status => damaged }, if the Item is damaged.
{ status => cannotReserveFromOtherBranches }, if syspref 'canreservefromotherbranches' is OK.
+ { status => branchNotInHoldGroup }, if borrower home library is not in hold group, and holds are only allowed from hold groups.
{ status => tooManyReserves, limit => $limit }, if the borrower has exceeded their maximum reserve amount.
{ 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
+ { status => pickupNotInHoldGroup }, pickup location is not in hold group, and pickup locations are only allowed from hold groups.
=cut
# we retrieve count
- $querycount .= "AND $branchfield = ?";
+ $querycount .= "AND ( $branchfield = ? OR $branchfield IS NULL )";
# If using item-level itypes, fall back to the record
# level itemtype if the hold has no associated item
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 $reserves_control_branch =
+ GetReservesControlBranch( $item->unblessed(), $borrower );
my $branchitemrule =
- C4::Circulation::GetBranchItemRule( $circ_control_branch, $item->itype ); # FIXME Should not be item->effective_itemtype?
+ C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->itype ); # FIXME Should not be item->effective_itemtype?
if ( $branchitemrule->{holdallowed} == 0 ) {
return { status => 'notReservable' };
return { status => 'cannotReserveFromOtherBranches' };
}
+ my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
+ if ( $branchitemrule->{holdallowed} == 3) {
+ if($borrower->{branchcode} ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $borrower->{branchcode}} )) {
+ return { status => 'branchNotInHoldGroup' };
+ }
+ }
+
# If reservecount is ok, we check item branch if IndependentBranches is ON
# and canreservefromotherbranches is OFF
if ( C4::Context->preference('IndependentBranches')
unless ($item->can_be_transferred({ to => $destination })) {
return { status => 'cannotBeTransferred' };
}
+ unless ($branchitemrule->{hold_fulfillment_policy} ne 'holdgroup' || $item_library->validate_hold_sibling( {branchcode => $pickup_branchcode} )) {
+ return { status => 'pickupNotInHoldGroup' };
+ }
+ unless ($branchitemrule->{hold_fulfillment_policy} ne 'patrongroup' || Koha::Libraries->find({branchcode => $borrower->{branchcode}})->validate_hold_sibling({branchcode => $pickup_branchcode})) {
+ return { status => 'pickupNotInHoldGroup' };
+ }
}
return { status => 'OK' };
Koha::Account->new( { patron_id => $borrowernumber } )->add_debit(
{
amount => $fee,
- description => "Reserve Charge - " . $title,
+ description => $title,
note => undef,
user_id => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
library_id => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
- sip => undef,
+ interface => C4::Context->interface,
invoice_type => undef,
- type => 'reserve',
+ type => 'RESERVE',
item_id => undef
}
);
=head2 CheckReserves
- ($status, $reserve, $all_reserves) = &CheckReserves($itemnumber);
- ($status, $reserve, $all_reserves) = &CheckReserves(undef, $barcode);
- ($status, $reserve, $all_reserves) = &CheckReserves($itemnumber,undef,$lookahead);
+ ($status, $matched_reserve, $possible_reserves) = &CheckReserves($itemnumber);
+ ($status, $matched_reserve, $possible_reserves) = &CheckReserves(undef, $barcode);
+ ($status, $matched_reserve, $possible_reserves) = &CheckReserves($itemnumber,undef,$lookahead);
Find a book in the reserves.
}
# note: we get the itemnumber because we might have started w/ just the barcode. Now we know for sure we have it.
my ( $biblio, $bibitem, $notforloan_per_itemtype, $notforloan_per_item, $itemnumber, $damaged, $item_homebranch, $item_holdingbranch ) = $sth->fetchrow_array;
-
return if ( $damaged && !C4::Context->preference('AllowHoldsOnDamagedItems') );
return unless $itemnumber; # bail if we got nothing.
-
# if item is not for loan it cannot be reserved either.....
# except where items.notforloan < 0 : This indicates the item is holdable.
return if ( $notforloan_per_item > 0 ) or $notforloan_per_itemtype;
my $branchitemrule = C4::Circulation::GetBranchItemRule($branch,$item->effective_itemtype);
next if ($branchitemrule->{'holdallowed'} == 0);
next if (($branchitemrule->{'holdallowed'} == 1) && ($branch ne $patron->branchcode));
+ my $library = Koha::Libraries->find({branchcode=>$item->homebranch});
+ next if (($branchitemrule->{'holdallowed'} == 3) && (!$library->validate_hold_sibling({branchcode => $patron->branchcode}) ));
my $hold_fulfillment_policy = $branchitemrule->{hold_fulfillment_policy};
- next if ( ($branchitemrule->{hold_fulfillment_policy} ne 'any') && ($res->{branchcode} ne $item->$hold_fulfillment_policy) );
+ next if ( ($hold_fulfillment_policy eq 'holdgroup') && (!$library->validate_hold_sibling({branchcode => $res->{branchcode}})) );
+ next if ( ($hold_fulfillment_policy eq 'homebranch') && ($res->{branchcode} ne $item->$hold_fulfillment_policy) );
+ next if ( ($hold_fulfillment_policy eq 'holdingbranch') && ($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;
my $dtf = Koha::Database->new->schema->storage->datetime_parser;
my $params = { expirationdate => { '<', $dtf->format_date($today) } };
- $params->{found} = undef unless $expireWaiting;
+ $params->{found} = [ { '!=', 'W' }, undef ] unless $expireWaiting;
# FIXME To move to Koha::Holds->search_expired (?)
my $holds = Koha::Holds->search( $params );
logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->unblessed) )
if C4::Context->preference('HoldsLog');
- $hold->set(
- {
- priority => $rank,
- branchcode => $branchcode,
- itemnumber => $itemnumber,
- found => undef,
- waitingdate => undef
- }
- )->store();
+ my $properties = {
+ priority => $rank,
+ branchcode => $branchcode,
+ itemnumber => $itemnumber,
+ found => undef,
+ waitingdate => undef
+ };
+ if (exists $params->{reservedate}) {
+ $properties->{reservedate} = $params->{reservedate} || undef;
+ }
+ if (exists $params->{expirationdate}) {
+ $properties->{expirationdate} = $params->{expirationdate} || undef;
+ }
+
+ $hold->set($properties)->store();
if ( defined( $suspend_until ) ) {
if ( $suspend_until ) {
my $reserve_id = $res->{'reserve_id'};
my $hold = Koha::Holds->find($reserve_id);
-
# get the priority on this record....
my $priority = $hold->priority;
my $sth_set = $dbh->prepare($query);
$sth_set->execute( $newstatus, $itemnumber );
- if ( C4::Context->preference("ReturnToShelvingCart") && $newstatus ) {
+ my $item = Koha::Items->find($itemnumber);
+ if ( $item->location && $item->location eq 'CART'
+ && ( !$item->permanent_location || $item->permanent_location ne 'CART' )
+ && $newstatus ) {
CartToShelf( $itemnumber );
}
}
if ( !$transferToDo && !$already_on_shelf );
_FixPriority( { biblionumber => $biblionumber } );
-
- if ( C4::Context->preference("ReturnToShelvingCart") ) {
- CartToShelf($itemnumber);
+ my $item = Koha::Items->find($itemnumber);
+ if ( $item->location && $item->location eq 'CART'
+ && ( !$item->permanent_location || $item->permanent_location ne 'CART' ) ) {
+ CartToShelf( $itemnumber );
}
return;
=cut
sub IsAvailableForItemLevelRequest {
- my $item = shift;
- my $borrower = shift;
- my $pickup_branchcode = shift;
+ my ( $item, $patron, $pickup_branchcode ) = @_;
my $dbh = C4::Context->dbh;
# must check the notforloan setting of the itemtype
# FIXME - a lot of places in the code do this
# or something similar - need to be
# consolidated
- my $patron = Koha::Patrons->find( $borrower->{borrowernumber} );
- my $item_object = Koha::Items->find( $item->{itemnumber } );
- my $itemtype = $item_object->effective_itemtype;
- my $notforloan_per_itemtype
- = $dbh->selectrow_array("SELECT notforloan FROM itemtypes WHERE itemtype = ?",
- undef, $itemtype);
+ my $itemtype = $item->effective_itemtype;
+ my $notforloan_per_itemtype = Koha::ItemTypes->find($itemtype)->notforloan;
return 0 if
$notforloan_per_itemtype ||
- $item->{itemlost} ||
- $item->{notforloan} > 0 ||
- $item->{withdrawn} ||
- ($item->{damaged} && !C4::Context->preference('AllowHoldsOnDamagedItems'));
+ $item->itemlost ||
+ $item->notforloan > 0 ||
+ $item->withdrawn ||
+ ($item->damaged && !C4::Context->preference('AllowHoldsOnDamagedItems'));
- my $on_shelf_holds = Koha::IssuingRules->get_onshelfholds_policy( { item => $item_object, patron => $patron } );
+ my $on_shelf_holds = Koha::IssuingRules->get_onshelfholds_policy( { item => $item, 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 } );
+ return 0 unless $item->can_be_transferred( { to => $destination } );
+ my $reserves_control_branch =
+ GetReservesControlBranch( $item->unblessed(), $patron->unblessed() );
+ my $branchitemrule =
+ C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->itype );
+ my $home_library = Koka::Libraries->find( {branchcode => $item->homebranch} );
+ return 0 unless $branchitemrule->{hold_fulfillment_policy} ne 'holdgroup' || $home_library->validate_hold_sibling( {branchcode => $pickup_branchcode} );
}
if ( $on_shelf_holds == 1 ) {
return 1;
} elsif ( $on_shelf_holds == 2 ) {
my @items =
- Koha::Items->search( { biblionumber => $item->{biblionumber} } );
+ Koha::Items->search( { biblionumber => $item->biblionumber } );
my $any_available = 0;
foreach my $i (@items) {
+ my $reserves_control_branch = GetReservesControlBranch( $i->unblessed(), $patron->unblessed );
+ my $branchitemrule = C4::Circulation::GetBranchItemRule( $reserves_control_branch, $i->itype );
+ my $item_library = Koha::Libraries->find( {branchcode => $i->homebranch} );
- my $circ_control_branch = C4::Circulation::_GetCircControlBranch( $i->unblessed(), $borrower );
- my $branchitemrule = C4::Circulation::GetBranchItemRule( $circ_control_branch, $i->itype );
$any_available = 1
unless $i->itemlost
|| ( $i->damaged
&& !C4::Context->preference('AllowHoldsOnDamagedItems') )
|| Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
- || $branchitemrule->{holdallowed} == 1 && $borrower->{branchcode} ne $i->homebranch;
+ || $branchitemrule->{holdallowed} == 1 && $patron->branchcode ne $i->homebranch
+ || $branchitemrule->{holdallowed} == 3 && !$item_library->validate_hold_sibling( {branchcode => $patron->branchcode} );
}
return $any_available ? 0 : 1;
} else { # on_shelf_holds == 0 "If any unavailable" (the description is rather cryptic and could still be improved)
- return $item->{onloan} || IsItemOnHoldAndFound( $item->{itemnumber} );
+ return $item->onloan || IsItemOnHoldAndFound( $item->itemnumber );
}
}
if ( $rank eq "del" ) { # FIXME will crash if called without $hold
$hold->cancel;
}
- elsif ( $rank eq "W" || $rank eq "0" ) {
+ elsif ( $reserve_id && ( $rank eq "W" || $rank eq "0" ) ) {
# make sure priority for waiting or in-transit items is 0
my $query = "
push( @priority, $line );
}
+ # FIXME This whole sub must be rewritten, especially to highlight what is done when reserve_id is not given
# To find the matching index
my $i;
my $key = -1; # to allow for 0 to be a valid result
for ( $i = 0 ; $i < @priority ; $i++ ) {
- if ( $reserve_id == $priority[$i]->{'reserve_id'} ) {
+ if ( $reserve_id && $reserve_id == $priority[$i]->{'reserve_id'} ) {
$key = $i; # save the index
last;
}
fields from the reserves table of the Koha database, plus
C<biblioitemnumber>.
+This routine with either return:
+1 - Item specific holds from the holds queue
+2 - Title level holds from the holds queue
+3 - All holds for this biblionumber
+
+All return values will respect any borrowernumbers passed as arrayref in $ignore_borrowers
+
=cut
sub _Findgroupreserve {
my ( $itemnumber, $borrowernumber, $cancelreserve ) = @_;
my $lookahead = C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
- my ( $restype, $res, $all_reserves ) = CheckReserves( $itemnumber, undef, $lookahead );
+ my ( $restype, $res, undef ) = CheckReserves( $itemnumber, undef, $lookahead );
return unless $res;
my $biblionumber = $res->{biblionumber};
# The item is reserved by someone else.
# Find this item in the reserves
- my $borr_res;
- foreach (@$all_reserves) {
- $_->{'borrowernumber'} == $borrowernumber or next;
- $_->{'biblionumber'} == $biblionumber or next;
-
- $borr_res = $_;
- last;
- }
+ my $borr_res = Koha::Holds->search({
+ borrowernumber => $borrowernumber,
+ biblionumber => $biblionumber,
+ },{
+ order_by => 'priority'
+ })->next();
if ( $borr_res ) {
# The item is reserved by the current patron
- ModReserveFill($borr_res);
+ ModReserveFill($borr_res->unblessed);
}
if ( $cancelreserve eq 'revert' ) { ## Revert waiting reserve to priority 1
$sth->execute( $itemnumber );
my $reserve = $sth->fetchrow_hashref();
+ my $hold = Koha::Holds->find( $reserve->{reserve_id} ); # TODO Remove the next raw SQL statements and use this instead
+
## Increment the priority of all other non-waiting
## reserves for this bib record
$query = "
";
$sth = $dbh->prepare( $query );
$sth->execute( $reserve->{'reserve_id'} );
+
+ unless ( $hold->item_level_hold ) {
+ $hold->itemnumber(undef)->store;
+ }
+
_FixPriority( { biblionumber => $reserve->{biblionumber} } );
}
projects / srvgit / blobdiff