use Modern::Perl;
use C4::Accounts;
-use C4::Biblio;
-use C4::Circulation;
+use C4::Circulation qw( CheckIfIssuedToPatron GetAgeRestriction GetBranchItemRule );
use C4::Context;
-use C4::Items;
+use C4::Items qw( CartToShelf get_hostitemnumbers_of );
use C4::Letters;
-use C4::Log;
+use C4::Log qw( logaction );
use C4::Members::Messaging;
use C4::Members;
use Koha::Account::Lines;
use Koha::Calendar;
use Koha::CirculationRules;
use Koha::Database;
-use Koha::DateUtils;
+use Koha::DateUtils qw( dt_from_string output_pref );
use Koha::Hold;
use Koha::Holds;
use Koha::ItemTypes;
use Koha::Libraries;
use Koha::Old::Hold;
use Koha::Patrons;
+use Koha::Plugins;
-use Carp;
-use Data::Dumper;
-use List::MoreUtils qw( firstidx any );
-
-use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
+use Data::Dumper qw( Dumper );
+use List::MoreUtils qw( any );
=head1 NAME
The following columns contains important values :
- priority >0 : then the reserve is at 1st stage, and not yet affected to any item.
=0 : then the reserve is being dealed
- - found : NULL : means the patron requested the 1st available, and we haven't chosen the item
- T(ransit) : the reserve is linked to an item but is in transit to the pickup branch
- W(aiting) : the reserve is linked to an item, is at the pickup branch, and is waiting on the hold shelf
- F(inished) : the reserve has been completed, and is done
+ - found : NULL : means the patron requested the 1st available, and we haven't chosen the item
+ T(ransit) : the reserve is linked to an item but is in transit to the pickup branch
+ W(aiting) : the reserve is linked to an item, is at the pickup branch, and is waiting on the hold shelf
+ F(inished) : the reserve has been completed, and is done
+ P(rocessing) : reserved item has been returned using self-check machine and reserve needs to be confirmed
+ by librarian before notice is send and status changed to waiting.
+ Applicable only if HoldsNeedProcessingSIP system preference is set.
- itemnumber : empty : the reserve is still unaffected to an item
filled: the reserve is attached to an item
The complete workflow is :
=cut
+our (@ISA, @EXPORT_OK);
BEGIN {
require Exporter;
@ISA = qw(Exporter);
- @EXPORT = qw(
- &AddReserve
+ @EXPORT_OK = qw(
+ AddReserve
+
+ GetReserveStatus
+
+ GetOtherReserves
+ ChargeReserveFee
+ GetReserveFee
- &GetReserveStatus
+ ModReserveFill
+ ModReserveAffect
+ ModReserve
+ ModReserveStatus
+ ModReserveCancelAll
+ ModReserveMinusPriority
+ MoveReserve
- &GetOtherReserves
+ CheckReserves
+ CanBookBeReserved
+ CanItemBeReserved
+ CanReserveBeCanceledFromOpac
+ CancelExpiredReserves
- &ModReserveFill
- &ModReserveAffect
- &ModReserve
- &ModReserveStatus
- &ModReserveCancelAll
- &ModReserveMinusPriority
- &MoveReserve
+ AutoUnsuspendReserves
- &CheckReserves
- &CanBookBeReserved
- &CanItemBeReserved
- &CanReserveBeCanceledFromOpac
- &CancelExpiredReserves
+ IsAvailableForItemLevelRequest
+ ItemsAnyAvailableAndNotRestricted
- &AutoUnsuspendReserves
+ AlterPriority
+ ToggleLowestPriority
- &IsAvailableForItemLevelRequest
- ItemsAnyAvailableForHold
+ ReserveSlip
+ ToggleSuspend
+ SuspendAll
- &AlterPriority
- &ToggleLowestPriority
+ GetReservesControlBranch
- &ReserveSlip
- &ToggleSuspend
- &SuspendAll
+ CalculatePriority
- &GetReservesControlBranch
+ IsItemOnHoldAndFound
- IsItemOnHoldAndFound
+ GetMaxPatronHoldsForRecord
- GetMaxPatronHoldsForRecord
+ MergeHolds
+
+ RevertWaitingStatus
);
- @EXPORT_OK = qw( MergeHolds );
}
=head2 AddReserve
AddReserve(
{
- branch => $branchcode,
+ branchcode => $branchcode,
borrowernumber => $borrowernumber,
biblionumber => $biblionumber,
priority => $priority,
my $checkitem = $params->{itemnumber};
my $found = $params->{found};
my $itemtype = $params->{itemtype};
+ my $non_priority = $params->{non_priority};
$resdate = output_pref( { str => dt_from_string( $resdate ), dateonly => 1, dateformat => 'iso' })
or output_pref({ dt => dt_from_string, dateonly => 1, dateformat => 'iso' });
expirationdate => $expdate,
itemtype => $itemtype,
item_level_hold => $checkitem ? 1 : 0,
+ non_priority => $non_priority ? 1 : 0,
}
)->store();
$hold->set_waiting() if $found && $found eq 'W';
}
}
+ Koha::Plugins->call('after_hold_create', $hold);
+
return $reserve_id;
}
=head2 CanBookBeReserved
- $canReserve = &CanBookBeReserved($borrowernumber, $biblionumber, $branchcode)
+ $canReserve = &CanBookBeReserved($borrowernumber, $biblionumber, $branchcode, $params)
if ($canReserve eq 'OK') { #We can reserve this Item! }
+ $params are passed directly through to CanItemBeReserved
+
See CanItemBeReserved() for possible return values.
=cut
sub CanBookBeReserved{
- my ($borrowernumber, $biblionumber, $pickup_branchcode) = @_;
+ my ($borrowernumber, $biblionumber, $pickup_branchcode, $params) = @_;
+
+ # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
+ if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
+ && C4::Circulation::CheckIfIssuedToPatron( $borrowernumber, $biblionumber ) ) {
+ return { status =>'alreadypossession' };
+ }
my @itemnumbers = Koha::Items->search({ biblionumber => $biblionumber})->get_column("itemnumber");
#get items linked via host records
my $canReserve = { status => '' };
foreach my $itemnumber (@itemnumbers) {
- $canReserve = CanItemBeReserved( $borrowernumber, $itemnumber, $pickup_branchcode );
+ $canReserve = CanItemBeReserved( $borrowernumber, $itemnumber, $pickup_branchcode, $params );
return { status => 'OK' } if $canReserve->{status} eq 'OK';
}
return $canReserve;
=head2 CanItemBeReserved
- $canReserve = &CanItemBeReserved($borrowernumber, $itemnumber, $branchcode)
+ $canReserve = &CanItemBeReserved($borrowernumber, $itemnumber, $branchcode, $params)
if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }
+ current params are:
+ 'ignore_found_holds' - if true holds that have been trapped are not counted
+ toward the patron limit, used by checkHighHolds to avoid counting the hold we will fill with the
+ current checkout against the high holds threshold
+ 'ignore_hold_counts' - we use this routine to check if an item can fill a hold - on this case we
+ should not check if there are too many holds as we only csre about reservability
+
@RETURNS { status => OK }, if the Item can be reserved.
{ status => ageRestricted }, if the Item is age restricted for this borrower.
{ status => damaged }, if the Item is damaged.
=cut
sub CanItemBeReserved {
- my ( $borrowernumber, $itemnumber, $pickup_branchcode ) = @_;
+ my ( $borrowernumber, $itemnumber, $pickup_branchcode, $params ) = @_;
my $dbh = C4::Context->dbh;
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
+ my $allowedreserves = 0; # Total number of holds allowed across all records, default to none
# we retrieve borrowers and items informations #
# item->{itype} will come for biblioitems if necessery
# Check that the patron doesn't have an item level hold on this item already
return { status =>'itemAlreadyOnHold' }
- if Koha::Holds->search( { borrowernumber => $borrowernumber, itemnumber => $itemnumber } )->count();
+ if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $borrowernumber, itemnumber => $itemnumber } )->count() );
+
+ # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
+ if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
+ && C4::Circulation::CheckIfIssuedToPatron( $patron->borrowernumber, $biblio->biblionumber ) ) {
+ return { status =>'alreadypossession' };
+ }
my $controlbranch = C4::Context->preference('ReservesControlBranch');
}
# we retrieve rights
- if ( my $rights = GetHoldRule( $borrower->{'categorycode'}, $item->effective_itemtype, $branchcode ) ) {
- $ruleitemtype = $rights->{itemtype};
- $allowedreserves = $rights->{reservesallowed} // $allowedreserves;
- $holds_per_record = $rights->{holds_per_record} // $holds_per_record;
- $holds_per_day = $rights->{holds_per_day};
+ if (
+ my $reservesallowed = Koha::CirculationRules->get_effective_rule({
+ itemtype => $item->effective_itemtype,
+ categorycode => $borrower->{categorycode},
+ branchcode => $branchcode,
+ rule_name => 'reservesallowed',
+ })
+ ) {
+ $ruleitemtype = $reservesallowed->itemtype;
+ $allowedreserves = $reservesallowed->rule_value // 0; #undefined is 0, blank is unlimited
}
else {
$ruleitemtype = undef;
}
- my $holds = Koha::Holds->search(
- {
- borrowernumber => $borrowernumber,
- biblionumber => $item->biblionumber,
+ my $rights = Koha::CirculationRules->get_effective_rules({
+ categorycode => $borrower->{'categorycode'},
+ itemtype => $item->effective_itemtype,
+ branchcode => $branchcode,
+ rules => ['holds_per_record','holds_per_day']
+ });
+ my $holds_per_record = $rights->{holds_per_record} // 1;
+ my $holds_per_day = $rights->{holds_per_day};
+
+ my $search_params = {
+ borrowernumber => $borrowernumber,
+ biblionumber => $item->biblionumber,
+ };
+ $search_params->{found} = undef if $params->{ignore_found_holds};
+
+ my $holds = Koha::Holds->search($search_params);
+ if ( defined $holds_per_record && $holds_per_record ne '' ){
+ if ( $holds_per_record == 0 ) {
+ return { status => "noReservesAllowed" };
+ }
+ if ( !$params->{ignore_hold_counts} && $holds->count() >= $holds_per_record ) {
+ return { status => "tooManyHoldsForThisRecord", limit => $holds_per_record };
}
- );
- if ( defined $holds_per_record && $holds_per_record ne ''
- && $holds->count() >= $holds_per_record ) {
- return { status => "tooManyHoldsForThisRecord", limit => $holds_per_record };
}
my $today_holds = Koha::Holds->search({
reservedate => dt_from_string->date
});
- if ( defined $holds_per_day && $holds_per_day ne ''
+ if (!$params->{ignore_hold_counts} && defined $holds_per_day && $holds_per_day ne ''
&& $today_holds->count() >= $holds_per_day )
{
return { status => 'tooManyReservesToday', limit => $holds_per_day };
}
# we check if it's ok or not
- if ( defined $allowedreserves && $allowedreserves ne ''
- && $reservecount >= $allowedreserves ) {
- return { status => 'tooManyReserves', limit => $allowedreserves };
+ if ( defined $allowedreserves && $allowedreserves ne '' ){
+ if( $allowedreserves == 0 ){
+ return { status => 'noReservesAllowed' };
+ }
+ if ( !$params->{ignore_hold_counts} && $reservecount >= $allowedreserves ) {
+ return { status => 'tooManyReserves', limit => $allowedreserves };
+ }
}
# Now we need to check hold limits by patron category
rule_name => 'max_holds',
}
);
- if ( $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
+ if (!$params->{ignore_hold_counts} && $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
my $total_holds_count = Koha::Holds->search(
{
borrowernumber => $borrower->{borrowernumber}
my $reserves_control_branch =
GetReservesControlBranch( $item->unblessed(), $borrower );
my $branchitemrule =
- C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->itype ); # FIXME Should not be item->effective_itemtype?
+ C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->effective_itemtype );
- if ( $branchitemrule->{holdallowed} == 0 ) {
+ if ( $branchitemrule->{holdallowed} eq 'not_allowed' ) {
return { status => 'notReservable' };
}
- if ( $branchitemrule->{holdallowed} == 1
+ if ( $branchitemrule->{holdallowed} eq 'from_home_library'
&& $borrower->{branchcode} ne $item->homebranch )
{
return { status => 'cannotReserveFromOtherBranches' };
}
my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
- if ( $branchitemrule->{holdallowed} == 3) {
+ if ( $branchitemrule->{holdallowed} eq 'from_local_hold_group') {
if($borrower->{branchcode} ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $borrower->{branchcode}} )) {
return { status => 'branchNotInHoldGroup' };
}
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} )) {
+ if ($branchitemrule->{hold_fulfillment_policy} eq '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})) {
+ if ($branchitemrule->{hold_fulfillment_policy} eq 'patrongroup' && !Koha::Libraries->find({branchcode => $borrower->{branchcode}})->validate_hold_sibling({branchcode => $pickup_branchcode})) {
return { status => 'pickupNotInHoldGroup' };
}
}
my ($reserve_id, $borrowernumber) = @_;
return unless $reserve_id and $borrowernumber;
- my $reserve = Koha::Holds->find($reserve_id);
+ my $reserve = Koha::Holds->find($reserve_id) or return;
return 0 unless $reserve->borrowernumber == $borrowernumber;
- return 0 if ( $reserve->found eq 'W' ) or ( $reserve->found eq 'T' );
-
- return 1;
-
+ return $reserve->is_cancelable_from_opac;
}
=head2 GetOtherReserves
ModReserveStatus($itemnumber,'W');
}
- $nextreservinfo = $checkreserves->{'borrowernumber'};
+ $nextreservinfo = $checkreserves;
}
return ( $messages, $nextreservinfo );
if(defined $found) {
return 'Waiting' if $found eq 'W' and $priority == 0;
+ return 'Processing' if $found eq 'P';
return 'Finished' if $found eq 'F';
}
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 @SkipHoldTrapOnNotForLoanValue = split( '\|', C4::Context->preference('SkipHoldTrapOnNotForLoanValue') );
+ return if grep { $_ eq $notforloan_per_item } @SkipHoldTrapOnNotForLoanValue;
+
+ my $dont_trap = C4::Context->preference('TrapHoldsOnOrder') ? ($notforloan_per_item > 0) : ($notforloan_per_item && 1 );
+ return if $dont_trap or $notforloan_per_itemtype;
# Find this item in the reserves
my @reserves = _Findgroupreserve( $bibitem, $biblio, $itemnumber, $lookahead_days, $ignore_borrowers);
# the more important the item.)
# $highest is the most important item we've seen so far.
my $highest;
+
if (scalar @reserves) {
my $LocalHoldsPriority = C4::Context->preference('LocalHoldsPriority');
my $LocalHoldsPriorityPatronControl = C4::Context->preference('LocalHoldsPriorityPatronControl');
my $priority = 10000000;
foreach my $res (@reserves) {
- if ( $res->{'itemnumber'} && $res->{'itemnumber'} == $itemnumber && $res->{'priority'} == 0) {
- if ($res->{'found'} eq 'W') {
- return ( "Waiting", $res, \@reserves ); # Found it, it is waiting
- } else {
- return ( "Reserved", $res, \@reserves ); # Found determinated hold, e. g. the tranferred one
- }
+ if ($res->{'found'} && $res->{'found'} eq 'W') {
+ return ( "Waiting", $res, \@reserves ); # Found it, it is waiting
+ } elsif ($res->{'found'} && $res->{'found'} eq 'P') {
+ return ( "Processing", $res, \@reserves ); # Found determinated hold, e. g. the transferred one
+ } elsif ($res->{'found'} && $res->{'found'} eq 'T') {
+ return ( "Transferred", $res, \@reserves ); # Found determinated hold, e. g. the transferred one
} else {
my $patron;
my $item;
$patron = Koha::Patrons->find( $res->{borrowernumber} );
$item = Koha::Items->find($itemnumber);
- my $local_holds_priority_item_branchcode =
- $item->$LocalHoldsPriorityItemControl;
- my $local_holds_priority_patron_branchcode =
- ( $LocalHoldsPriorityPatronControl eq 'PickupLibrary' )
- ? $res->{branchcode}
- : ( $LocalHoldsPriorityPatronControl eq 'HomeLibrary' )
- ? $patron->branchcode
- : undef;
- $local_hold_match =
- $local_holds_priority_item_branchcode eq
- $local_holds_priority_patron_branchcode;
+ unless ($item->exclude_from_local_holds_priority || $patron->category->exclude_from_local_holds_priority) {
+ my $local_holds_priority_item_branchcode =
+ $item->$LocalHoldsPriorityItemControl;
+ my $local_holds_priority_patron_branchcode =
+ ( $LocalHoldsPriorityPatronControl eq 'PickupLibrary' )
+ ? $res->{branchcode}
+ : ( $LocalHoldsPriorityPatronControl eq 'HomeLibrary' )
+ ? $patron->branchcode
+ : undef;
+ $local_hold_match =
+ $local_holds_priority_item_branchcode eq
+ $local_holds_priority_patron_branchcode;
+ }
}
# See if this item is more important than what we've got so far
$patron ||= Koha::Patrons->find( $res->{borrowernumber} );
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->{'holdallowed'} eq 'not_allowed');
+ next if (($branchitemrule->{'holdallowed'} eq 'from_home_library') && ($item->homebranch ne $patron->branchcode));
my $library = Koha::Libraries->find({branchcode=>$item->homebranch});
- next if (($branchitemrule->{'holdallowed'} == 3) && (!$library->validate_hold_sibling({branchcode => $patron->branchcode}) ));
+ next if (($branchitemrule->{'holdallowed'} eq 'from_local_hold_group') && (!$library->validate_hold_sibling({branchcode => $patron->branchcode}) ));
my $hold_fulfillment_policy = $branchitemrule->{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) );
=cut
sub CancelExpiredReserves {
+ my $cancellation_reason = shift;
my $today = dt_from_string();
my $cancel_on_holidays = C4::Context->preference('ExpireReservesOnHolidays');
my $expireWaiting = C4::Context->preference('ExpireReservesMaxPickUpDelay');
next if !$cancel_on_holidays && $calendar->is_holiday( $today );
my $cancel_params = {};
- if ( $hold->found eq 'W' ) {
+ $cancel_params->{cancellation_reason} = $cancellation_reason if defined($cancellation_reason);
+ if ( defined($hold->found) && $hold->found eq 'W' ) {
$cancel_params->{charge_cancel_fee} = 1;
}
$hold->cancel( $cancel_params );
my $suspend_until = $params->{'suspend_until'};
my $borrowernumber = $params->{'borrowernumber'};
my $biblionumber = $params->{'biblionumber'};
+ my $cancellation_reason = $params->{'cancellation_reason'};
return if $rank eq "W";
return if $rank eq "n";
$hold ||= Koha::Holds->find($reserve_id);
if ( $rank eq "del" ) {
- $hold->cancel;
+ $hold->cancel({ cancellation_reason => $cancellation_reason });
}
elsif ($rank =~ /^\d+/ and $rank > 0) {
logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->unblessed) )
=head2 ModReserveAffect
- &ModReserveAffect($itemnumber,$borrowernumber,$diffBranchSend,$reserve_id);
+ &ModReserveAffect($itemnumber,$borrowernumber,$diffBranchSend,$reserve_id, $desk_id);
This function affect an item and a status for a given reserve, either fetched directly
by record_id, or by borrowernumber and itemnumber or biblionumber. If only biblionumber
otherwise, a transfer is on the way, and the end of the transfer will
take care of the waiting status
+This function also removes any entry of the hold in holds queue table.
+
=cut
sub ModReserveAffect {
- my ( $itemnumber, $borrowernumber, $transferToDo, $reserve_id ) = @_;
+ my ( $itemnumber, $borrowernumber, $transferToDo, $reserve_id, $desk_id ) = @_;
my $dbh = C4::Context->dbh;
# we want to attach $itemnumber to $borrowernumber, find the biblionumber
my $already_on_shelf = $hold->found && $hold->found eq 'W';
$hold->itemnumber($itemnumber);
- $hold->set_waiting($transferToDo);
- _koha_notify_reserve( $hold->reserve_id )
- if ( !$transferToDo && !$already_on_shelf );
+ if ($transferToDo) {
+ $hold->set_transfer();
+ } elsif (C4::Context->preference('HoldsNeedProcessingSIP')
+ && C4::Context->interface eq 'sip'
+ && !$already_on_shelf) {
+ $hold->set_processing();
+ } else {
+ $hold->set_waiting($desk_id);
+ _koha_notify_reserve( $hold->reserve_id ) unless $already_on_shelf;
+ # Complete transfer if one exists
+ my $transfer = $hold->item->get_transfer;
+ $transfer->receive if $transfer;
+ }
_FixPriority( { biblionumber => $biblionumber } );
my $item = Koha::Items->find($itemnumber);
CartToShelf( $itemnumber );
}
- logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->unblessed) )
+ my $std = $dbh->prepare(q{
+ DELETE q, t
+ FROM tmp_holdsqueue q
+ INNER JOIN hold_fill_targets t
+ ON q.borrowernumber = t.borrowernumber
+ AND q.biblionumber = t.biblionumber
+ AND q.itemnumber = t.itemnumber
+ AND q.item_level_request = t.item_level_request
+ AND q.holdingbranch = t.source_branchcode
+ WHERE t.reserve_id = ?
+ });
+ $std->execute($hold->reserve_id);
+
+ logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->get_from_storage->unblessed) )
if C4::Context->preference('HoldsLog');
return;
=head2 ModReserveCancelAll
- ($messages,$nextreservinfo) = &ModReserveCancelAll($itemnumber,$borrowernumber);
+ ($messages,$nextreservinfo) = &ModReserveCancelAll($itemnumber,$borrowernumber,$reason);
function to cancel reserv,check other reserves, and transfer document if it's necessary
sub ModReserveCancelAll {
my $messages;
my $nextreservinfo;
- my ( $itemnumber, $borrowernumber ) = @_;
+ my ( $itemnumber, $borrowernumber, $cancellation_reason ) = @_;
#step 1 : cancel the reservation
my $holds = Koha::Holds->search({ itemnumber => $itemnumber, borrowernumber => $borrowernumber });
return unless $holds->count;
- $holds->next->cancel;
+ $holds->next->cancel({ cancellation_reason => $cancellation_reason });
#step 2 launch the subroutine of the others reserves
( $messages, $nextreservinfo ) = GetOtherReserves($itemnumber);
- return ( $messages, $nextreservinfo );
+ return ( $messages, $nextreservinfo->{borrowernumber} );
}
=head2 ModReserveMinusPriority
this routine does not check IndependentBranches
and canreservefromotherbranches.
+Note also that this subroutine does not checks smart
+rules limits for item by reservesallowed/holds_per_record
+values, this complemented in calling code with calls and
+checks with CanItemBeReserved or CanBookBeReserved.
+
=cut
sub IsAvailableForItemLevelRequest {
return 0 if
$notforloan_per_itemtype ||
$item->itemlost ||
- $item->notforloan > 0 ||
+ $item->notforloan > 0 || # item with negative or zero notforloan value is holdable
$item->withdrawn ||
($item->damaged && !C4::Context->preference('AllowHoldsOnDamagedItems'));
GetReservesControlBranch( $item->unblessed(), $patron->unblessed() );
my $branchitemrule =
C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->itype );
- my $home_library = Koka::Libraries->find( {branchcode => $item->homebranch} );
+ my $home_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
return 0 unless $branchitemrule->{hold_fulfillment_policy} ne 'holdgroup' || $home_library->validate_hold_sibling( {branchcode => $pickup_branchcode} );
}
return $items_any_available ? 0 : 1
if defined $items_any_available;
- my $any_available = ItemsAnyAvailableForHold( { biblionumber => $item->biblionumber, patron => $patron });
+ my $any_available = ItemsAnyAvailableAndNotRestricted( { biblionumber => $item->biblionumber, patron => $patron });
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 );
}
}
-=head2 ItemsAnyAvailableForHold
+=head2 ItemsAnyAvailableAndNotRestricted
- ItemsAnyAvailableForHold( { biblionumber => $biblionumber, patron => $patron });
+ ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron });
-This function checks all items for specified biblionumber (num) / patron (object)
-and returns true (1) or false (0) depending if any of rules allows at least of
-one item to be available for hold including lots of parameters/logic
+This function checks all items for specified biblionumber (numeric) against patron (object)
+and returns true (1) if at least one item available for loan/check out/present/not held
+and also checks other parameters logic which not restricts item for hold at all (for ex.
+AllowHoldsOnDamagedItems or 'holdallowed' own/sibling library)
=cut
-sub ItemsAnyAvailableForHold {
+sub ItemsAnyAvailableAndNotRestricted {
my $param = shift;
my @items = Koha::Items->search( { biblionumber => $param->{biblionumber} } );
- my $any_available = 0;
-
foreach my $i (@items) {
my $reserves_control_branch =
GetReservesControlBranch( $i->unblessed(), $param->{patron}->unblessed );
C4::Circulation::GetBranchItemRule( $reserves_control_branch, $i->itype );
my $item_library = Koha::Libraries->find( { branchcode => $i->homebranch } );
- $any_available = 1
+ # we can return (end the loop) when first one found:
+ return 1
unless $i->itemlost
- || $i->notforloan > 0
+ || $i->notforloan # items with non-zero notforloan cannot be checked out
|| $i->withdrawn
|| $i->onloan
|| IsItemOnHoldAndFound( $i->id )
|| ( $i->damaged
- && ! C4::Context->preference('AllowHoldsOnDamagedItems') )
+ && ! C4::Context->preference('AllowHoldsOnDamagedItems') )
|| Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
- || $branchitemrule->{holdallowed} == 1 && $param->{patron}->branchcode ne $i->homebranch
- || $branchitemrule->{holdallowed} == 3 && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } );
+ || $branchitemrule->{holdallowed} eq 'from_home_library' && $param->{patron}->branchcode ne $i->homebranch
+ || $branchitemrule->{holdallowed} eq 'from_local_hold_group' && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } )
+ || CanItemBeReserved( $param->{patron}->borrowernumber, $i->id )->{status} ne 'OK';
}
- return $any_available;
+ return 0;
}
=head2 AlterPriority
UPDATE reserves
SET priority = 0
WHERE reserve_id = ?
- AND found IN ('W', 'T')
+ AND found IN ('W', 'T', 'P')
";
my $sth = $dbh->prepare($query);
$sth->execute( $reserve_id );
SELECT reserve_id, borrowernumber, reservedate
FROM reserves
WHERE biblionumber = ?
- AND ((found <> 'W' AND found <> 'T') OR found IS NULL)
+ AND ((found <> 'W' AND found <> 'T' AND found <> 'P') OR found IS NULL)
ORDER BY priority ASC
";
my $sth = $dbh->prepare($query);
biblioitems.biblioitemnumber AS biblioitemnumber,
reserves.itemnumber AS itemnumber,
reserves.reserve_id AS reserve_id,
- reserves.itemtype AS itemtype
+ reserves.itemtype AS itemtype,
+ reserves.non_priority AS non_priority
FROM reserves
JOIN biblioitems USING (biblionumber)
- JOIN hold_fill_targets USING (biblionumber, borrowernumber, itemnumber)
+ JOIN hold_fill_targets USING (reserve_id)
WHERE found IS NULL
AND priority > 0
AND item_level_request = 1
- AND itemnumber = ?
+ AND hold_fill_targets.itemnumber = ?
AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
AND suspend = 0
ORDER BY priority
biblioitems.biblioitemnumber AS biblioitemnumber,
reserves.itemnumber AS itemnumber,
reserves.reserve_id AS reserve_id,
- reserves.itemtype AS itemtype
+ reserves.itemtype AS itemtype,
+ reserves.non_priority AS non_priority
FROM reserves
JOIN biblioitems USING (biblionumber)
- JOIN hold_fill_targets USING (biblionumber, borrowernumber)
+ JOIN hold_fill_targets USING (reserve_id)
WHERE found IS NULL
AND priority > 0
AND item_level_request = 0
reserves.timestamp AS timestamp,
reserves.itemnumber AS itemnumber,
reserves.reserve_id AS reserve_id,
- reserves.itemtype AS itemtype
+ reserves.itemtype AS itemtype,
+ reserves.non_priority AS non_priority
FROM reserves
WHERE reserves.biblionumber = ?
AND (reserves.itemnumber IS NULL OR reserves.itemnumber = ?)
message_name => 'Hold_Filled'
} );
- my $library = Koha::Libraries->find( $hold->branchcode )->unblessed;
-
- my $admin_email_address = $library->{branchemail} || C4::Context->preference('KohaAdminEmailAddress');
+ my $library = Koha::Libraries->find( $hold->branchcode );
+ my $admin_email_address = $library->from_email_address;
+ $library = $library->unblessed;
my %letter_params = (
module => 'reserves',
next if (
( $mtt eq 'email' and not $to_address ) # No email address
or ( $mtt eq 'sms' and not $patron->smsalertnumber ) # No SMS number
- or ( $mtt eq 'phone' and C4::Context->preference('TalkingTechItivaPhoneNotification') ) # Notice is handled by TalkingTech_itiva_outbound.pl
+ or ( $mtt eq 'itiva' and C4::Context->preference('TalkingTechItivaPhoneNotification') ) # Notice is handled by TalkingTech_itiva_outbound.pl
+ or ( $mtt eq 'phone' and not $patron->phone ) # No phone number to call
);
&$send_notification($mtt, $letter_code);
# don't reorder those already waiting
$sth = $dbh->prepare(
-"SELECT * FROM reserves WHERE biblionumber = ? AND (found <> ? AND found <> ? OR found is NULL) ORDER BY reservedate ASC"
+"SELECT * FROM reserves WHERE biblionumber = ? AND (found NOT IN ('W', 'T', 'P') OR found is NULL) ORDER BY reservedate ASC"
);
my $upd_sth = $dbh->prepare(
"UPDATE reserves SET priority = ? WHERE biblionumber = ? AND borrowernumber = ?
AND reservedate = ? AND (itemnumber = ? or itemnumber is NULL) "
);
- $sth->execute( $to_biblio, 'W', 'T' );
+ $sth->execute( $to_biblio );
my $priority = 1;
while ( my $reserve = $sth->fetchrow_hashref() ) {
$upd_sth->execute(
my $dbh = C4::Context->dbh;
## Get the waiting reserve we want to revert
- my $query = "
- SELECT * FROM reserves
- WHERE itemnumber = ?
- AND found IS NOT NULL
- ";
- my $sth = $dbh->prepare( $query );
- $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
+ my $hold = Koha::Holds->search(
+ {
+ itemnumber => $itemnumber,
+ found => { not => undef },
+ }
+ )->next;
## Increment the priority of all other non-waiting
## reserves for this bib record
- $query = "
- UPDATE reserves
- SET
- priority = priority + 1
- WHERE
- biblionumber = ?
- AND
- priority > 0
- ";
- $sth = $dbh->prepare( $query );
- $sth->execute( $reserve->{'biblionumber'} );
+ my $holds = Koha::Holds->search({ biblionumber => $hold->biblionumber, priority => { '>' => 0 } })
+ ->update({ priority => \'priority + 1' }, { no_triggers => 1 });
+ ## Fix up the currently waiting reserve
$hold->set(
{
priority => 1,
}
)->store();
- _FixPriority( { biblionumber => $reserve->{biblionumber} } );
+ _FixPriority( { biblionumber => $hold->biblionumber } );
return $hold;
}
sub ReserveSlip {
my ($args) = @_;
my $branchcode = $args->{branchcode};
- my $borrowernumber = $args->{borrowernumber};
- my $biblionumber = $args->{biblionumber};
- my $itemnumber = $args->{itemnumber};
- my $barcode = $args->{barcode};
-
-
- my $patron = Koha::Patrons->find($borrowernumber);
-
- my $hold;
- if ($itemnumber || $barcode ) {
- $itemnumber ||= Koha::Items->find( { barcode => $barcode } )->itemnumber;
-
- $hold = Koha::Holds->search(
- {
- biblionumber => $biblionumber,
- borrowernumber => $borrowernumber,
- itemnumber => $itemnumber
- }
- )->next;
- }
- else {
- $hold = Koha::Holds->search(
- {
- biblionumber => $biblionumber,
- borrowernumber => $borrowernumber
- }
- )->next;
- }
+ my $reserve_id = $args->{reserve_id};
+ my $hold = Koha::Holds->find($reserve_id);
return unless $hold;
+
+ my $patron = $hold->borrower;
my $reserve = $hold->unblessed;
return C4::Letters::GetPreparedLetter (
AND priority > 0
AND (found IS NULL OR found = '')
};
- #skip found==W or found==T (waiting or transit holds)
+ #skip found==W or found==T or found==P (waiting, transit or processing holds)
if( $resdate ) {
$sql.= ' AND ( reservedate <= ? )';
}
$branchcode = $item->homebranch if ( $controlbranch eq "ItemHomeLibrary" );
- my $rule = GetHoldRule( $categorycode, $itemtype, $branchcode );
- my $holds_per_record = $rule ? $rule->{holds_per_record} : 0;
- $max = $holds_per_record if $holds_per_record > $max;
- }
-
- return $max;
-}
-
-=head2 GetHoldRule
-
-my $rule = GetHoldRule( $categorycode, $itemtype, $branchcode );
-
-Returns the matching hold related issuingrule fields for a given
-patron category, itemtype, and library.
-
-=cut
-
-sub GetHoldRule {
- my ( $categorycode, $itemtype, $branchcode ) = @_;
-
- my $reservesallowed = Koha::CirculationRules->get_effective_rule(
- {
- itemtype => $itemtype,
+ my $rule = Koha::CirculationRules->get_effective_rule({
categorycode => $categorycode,
- branchcode => $branchcode,
- rule_name => 'reservesallowed',
- order_by => {
- -desc => [ 'categorycode', 'itemtype', 'branchcode' ]
- }
- }
- );
-
- my $rules;
- if ( $reservesallowed ) {
- $rules->{reservesallowed} = $reservesallowed->rule_value;
- $rules->{itemtype} = $reservesallowed->itemtype;
- $rules->{categorycode} = $reservesallowed->categorycode;
- $rules->{branchcode} = $reservesallowed->branchcode;
- }
-
- my $holds_per_x_rules = Koha::CirculationRules->get_effective_rules(
- {
itemtype => $itemtype,
- categorycode => $categorycode,
branchcode => $branchcode,
- rules => ['holds_per_record', 'holds_per_day'],
- order_by => {
- -desc => [ 'categorycode', 'itemtype', 'branchcode' ]
- }
- }
- );
- $rules->{holds_per_record} = $holds_per_x_rules->{holds_per_record};
- $rules->{holds_per_day} = $holds_per_x_rules->{holds_per_day};
+ rule_name => 'holds_per_record'
+ });
+ my $holds_per_record = $rule ? $rule->rule_value : 0;
+ $max = $holds_per_record if $holds_per_record > $max;
+ }
- return $rules;
+ return $max;
}
=head1 AUTHOR
projects / srvgit / blobdiff