use Modern::Perl;
use C4::Accounts;
+use C4::Biblio qw( GetMarcFromKohaField );
use C4::Circulation qw( CheckIfIssuedToPatron GetAgeRestriction GetBranchItemRule );
use C4::Context;
use C4::Items qw( CartToShelf get_hostitemnumbers_of );
use C4::Members::Messaging;
use C4::Members;
use Koha::Account::Lines;
+use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;
use Koha::Biblios;
use Koha::Calendar;
use Koha::CirculationRules;
use Koha::Database;
use Koha::DateUtils qw( dt_from_string output_pref );
-use Koha::Hold;
use Koha::Holds;
use Koha::ItemTypes;
use Koha::Items;
use Koha::Libraries;
-use Koha::Old::Hold;
+use Koha::Old::Holds;
use Koha::Patrons;
use Koha::Plugins;
-use Data::Dumper qw( Dumper );
use List::MoreUtils qw( any );
=head1 NAME
ChargeReserveFee
GetReserveFee
- ModReserveFill
ModReserveAffect
ModReserve
ModReserveStatus
my $biblionumber = $params->{biblionumber};
my $priority = $params->{priority};
my $resdate = $params->{reservation_date};
- my $expdate = $params->{expiration_date};
+ my $patron_expiration_date = $params->{expiration_date};
my $notes = $params->{notes};
my $title = $params->{title};
my $checkitem = $params->{itemnumber};
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' });
-
- $expdate = output_pref({ str => $expdate, dateonly => 1, dateformat => 'iso' });
+ $resdate ||= dt_from_string;
# 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 .
$found = 'W';
}
}
-
- if ( C4::Context->preference('AllowHoldDateInFuture') ) {
-
- # Make room in reserves for this before those of a later reserve date
- $priority = _ShiftPriorityByDateAndPriority( $biblionumber, $resdate, $priority );
+ if ( C4::Context->preference( 'AllowHoldDateInFuture' ) ) {
+ # Make room in reserves for this if passed a priority
+ $priority = _ShiftPriority( $biblionumber, $priority );
}
my $waitingdate;
itemnumber => $checkitem,
found => $found,
waitingdate => $waitingdate,
- expirationdate => $expdate,
+ patron_expiration_date => $patron_expiration_date,
itemtype => $itemtype,
item_level_hold => $checkitem ? 1 : 0,
non_priority => $non_priority ? 1 : 0,
)->store();
$hold->set_waiting() if $found && $found eq 'W';
- logaction( 'HOLDS', 'CREATE', $hold->id, Dumper($hold->unblessed) )
+ logaction( 'HOLDS', 'CREATE', $hold->id, $hold )
if C4::Context->preference('HoldsLog');
my $reserve_id = $hold->id();
}
Koha::Plugins->call('after_hold_create', $hold);
+ Koha::Plugins->call(
+ 'after_hold_action',
+ {
+ action => 'place',
+ payload => { hold => $hold->get_from_storage }
+ }
+ );
+
+ Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
+ {
+ biblio_ids => [ $biblionumber ]
+ }
+ ) if C4::Context->preference('RealTimeHoldsQueue');
return $reserve_id;
}
return { status =>'alreadypossession' };
}
- my @itemnumbers = Koha::Items->search({ biblionumber => $biblionumber})->get_column("itemnumber");
+ if ( $params->{itemtype} ) {
+
+ # biblio-level, item type-contrained
+ my $patron = Koha::Patrons->find($borrowernumber);
+ my $reservesallowed = Koha::CirculationRules->get_effective_rule(
+ {
+ itemtype => $params->{itemtype},
+ categorycode => $patron->categorycode,
+ branchcode => $pickup_branchcode,
+ rule_name => 'reservesallowed',
+ }
+ )->rule_value;
+
+ $reservesallowed = ( $reservesallowed eq '' ) ? undef : $reservesallowed;
+
+ my $count = $patron->holds->search(
+ {
+ '-or' => [
+ { 'me.itemtype' => $params->{itemtype} },
+ { 'item.itype' => $params->{itemtype} }
+ ]
+ },
+ {
+ join => ['item']
+ }
+ )->count;
+
+ return { status => '' }
+ if defined $reservesallowed and $reservesallowed < $count + 1;
+ }
+
+ my $items;
#get items linked via host records
- my @hostitems = get_hostitemnumbers_of($biblionumber);
- if (@hostitems){
- push (@itemnumbers, @hostitems);
+ my @hostitemnumbers = get_hostitemnumbers_of($biblionumber);
+ if (@hostitemnumbers){
+ $items = Koha::Items->search({
+ -or => [
+ biblionumber => $biblionumber,
+ itemnumber => { -in => @hostitemnumbers }
+ ]
+ });
+ } else {
+ $items = Koha::Items->search({ biblionumber => $biblionumber});
}
my $canReserve = { status => '' };
- foreach my $itemnumber (@itemnumbers) {
- $canReserve = CanItemBeReserved( $borrowernumber, $itemnumber, $pickup_branchcode, $params );
+ my $patron = Koha::Patrons->find( $borrowernumber );
+ while ( my $item = $items->next ) {
+ $canReserve = CanItemBeReserved( $patron, $item, $pickup_branchcode, $params );
return { status => 'OK' } if $canReserve->{status} eq 'OK';
}
return $canReserve;
=head2 CanItemBeReserved
- $canReserve = &CanItemBeReserved($borrowernumber, $itemnumber, $branchcode, $params)
+ $canReserve = &CanItemBeReserved($patron, $item, $branchcode, $params)
if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }
current params are:
{ 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.
+ { status => recall }, if the borrower has already placed a recall on this item
=cut
sub CanItemBeReserved {
- my ( $borrowernumber, $itemnumber, $pickup_branchcode, $params ) = @_;
+ my ( $patron, $item, $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, default to none
+ # We check item branch if IndependentBranches is ON
+ # and canreservefromotherbranches is OFF
+ if ( C4::Context->preference('IndependentBranches')
+ and !C4::Context->preference('canreservefromotherbranches') )
+ {
+ if ( $item->homebranch ne $patron->branchcode ) {
+ return { status => 'cannotReserveFromOtherBranches' };
+ }
+ }
+
# we retrieve borrowers and items informations #
# item->{itype} will come for biblioitems if necessery
- 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
if ( $item->damaged
&& !C4::Context->preference('AllowHoldsOnDamagedItems') );
- # Check for the age restriction
- my ( $ageRestriction, $daysToAgeRestriction ) =
- C4::Circulation::GetAgeRestriction( $biblio->biblioitem->agerestriction, $borrower );
- return { status => 'ageRestricted' } if $daysToAgeRestriction && $daysToAgeRestriction > 0;
+ if( GetMarcFromKohaField('biblioitems.agerestriction') ){
+ my $biblio = $item->biblio;
+ # Check for the age restriction
+ my ( $ageRestriction, $daysToAgeRestriction ) =
+ C4::Circulation::GetAgeRestriction( $biblio->biblioitem->agerestriction, $borrower );
+ return { status => 'ageRestricted' } if $daysToAgeRestriction && $daysToAgeRestriction > 0;
+ }
# Check that the patron doesn't have an item level hold on this item already
return { status =>'itemAlreadyOnHold' }
- if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $borrowernumber, itemnumber => $itemnumber } )->count() );
+ if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $patron->borrowernumber, itemnumber => $item->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 ) ) {
+ && C4::Circulation::CheckIfIssuedToPatron( $patron->borrowernumber, $item->biblionumber ) ) {
return { status =>'alreadypossession' };
}
- my $controlbranch = C4::Context->preference('ReservesControlBranch');
+ # check if a recall exists on this item from this borrower
+ return { status => 'recall' }
+ if $patron->recalls->filter_by_current->search({ item_id => $item->itemnumber })->count;
- my $querycount = q{
- SELECT count(*) AS count
- FROM reserves
- LEFT JOIN items USING (itemnumber)
- LEFT JOIN biblioitems ON (reserves.biblionumber=biblioitems.biblionumber)
- LEFT JOIN borrowers USING (borrowernumber)
- WHERE borrowernumber = ?
- };
+ my $controlbranch = C4::Context->preference('ReservesControlBranch');
- my $branchcode = "";
+ my $reserves_control_branch;
my $branchfield = "reserves.branchcode";
if ( $controlbranch eq "ItemHomeLibrary" ) {
$branchfield = "items.homebranch";
- $branchcode = $item->homebranch;
+ $reserves_control_branch = $item->homebranch;
}
elsif ( $controlbranch eq "PatronLibrary" ) {
$branchfield = "borrowers.branchcode";
- $branchcode = $borrower->{branchcode};
+ $reserves_control_branch = $borrower->{branchcode};
}
# we retrieve rights
my $reservesallowed = Koha::CirculationRules->get_effective_rule({
itemtype => $item->effective_itemtype,
categorycode => $borrower->{categorycode},
- branchcode => $branchcode,
+ branchcode => $reserves_control_branch,
rule_name => 'reservesallowed',
})
) {
my $rights = Koha::CirculationRules->get_effective_rules({
categorycode => $borrower->{'categorycode'},
itemtype => $item->effective_itemtype,
- branchcode => $branchcode,
+ branchcode => $reserves_control_branch,
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 ( !$params->{ignore_hold_counts} ) {
+ my $search_params = {
+ borrowernumber => $patron->borrowernumber,
+ biblionumber => $item->biblionumber,
+ };
+ $search_params->{found} = undef if $params->{ignore_found_holds};
+ my $holds = Koha::Holds->search($search_params);
+ return { status => "tooManyHoldsForThisRecord", limit => $holds_per_record } if $holds->count() >= $holds_per_record;
}
}
- my $today_holds = Koha::Holds->search({
- borrowernumber => $borrowernumber,
- reservedate => dt_from_string->date
- });
-
- if (!$params->{ignore_hold_counts} && defined $holds_per_day && $holds_per_day ne ''
- && $today_holds->count() >= $holds_per_day )
+ if (!$params->{ignore_hold_counts} && defined $holds_per_day && $holds_per_day ne '')
{
- return { status => 'tooManyReservesToday', limit => $holds_per_day };
- }
-
- # we retrieve count
-
- $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
- $querycount .=
- C4::Context->preference('item-level_itypes')
- ? " AND COALESCE( items.itype, biblioitems.itemtype ) = ?"
- : " AND biblioitems.itemtype = ?"
- if defined $ruleitemtype;
-
- my $sthcount = $dbh->prepare($querycount);
-
- if ( defined $ruleitemtype ) {
- $sthcount->execute( $borrowernumber, $branchcode, $ruleitemtype );
- }
- else {
- $sthcount->execute( $borrowernumber, $branchcode );
- }
-
- my $reservecount = "0";
- if ( my $rowcount = $sthcount->fetchrow_hashref() ) {
- $reservecount = $rowcount->{count};
+ my $today_holds = Koha::Holds->search({
+ borrowernumber => $patron->borrowernumber,
+ reservedate => dt_from_string->date
+ });
+ return { status => 'tooManyReservesToday', limit => $holds_per_day } if $today_holds->count() >= $holds_per_day;
}
# we check if it's ok or not
if( $allowedreserves == 0 ){
return { status => 'noReservesAllowed' };
}
- if ( !$params->{ignore_hold_counts} && $reservecount >= $allowedreserves ) {
- return { status => 'tooManyReserves', limit => $allowedreserves };
+ if ( !$params->{ignore_hold_counts} ) {
+ # we retrieve count
+ my $querycount = q{
+ SELECT count(*) AS count
+ FROM reserves
+ LEFT JOIN items USING (itemnumber)
+ LEFT JOIN biblioitems ON (reserves.biblionumber=biblioitems.biblionumber)
+ LEFT JOIN borrowers USING (borrowernumber)
+ WHERE borrowernumber = ?
+ };
+ $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
+ if ( defined $ruleitemtype ) {
+ if ( C4::Context->preference('item-level_itypes') ) {
+ $querycount .= q{
+ AND ( COALESCE( items.itype, biblioitems.itemtype ) = ?
+ OR reserves.itemtype = ? )
+ };
+ }
+ else {
+ $querycount .= q{
+ AND ( biblioitems.itemtype = ?
+ OR reserves.itemtype = ? )
+ };
+ }
+ }
+
+ my $sthcount = $dbh->prepare($querycount);
+
+ if ( defined $ruleitemtype ) {
+ $sthcount->execute( $patron->borrowernumber, $reserves_control_branch, $ruleitemtype, $ruleitemtype );
+ }
+ else {
+ $sthcount->execute( $patron->borrowernumber, $reserves_control_branch );
+ }
+
+ my $reservecount = "0";
+ if ( my $rowcount = $sthcount->fetchrow_hashref() ) {
+ $reservecount = $rowcount->{count};
+ }
+
+ return { status => 'tooManyReserves', limit => $allowedreserves } if $reservecount >= $allowedreserves;
}
}
# Now we need to check hold limits by patron category
my $rule = Koha::CirculationRules->get_effective_rule(
{
- categorycode => $borrower->{categorycode},
- branchcode => $branchcode,
+ categorycode => $patron->categorycode,
+ branchcode => $reserves_control_branch,
rule_name => 'max_holds',
}
);
if (!$params->{ignore_hold_counts} && $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
my $total_holds_count = Koha::Holds->search(
{
- borrowernumber => $borrower->{borrowernumber}
+ borrowernumber => $patron->borrowernumber
}
)->count();
return { status => 'tooManyReserves', limit => $rule->rule_value} if $total_holds_count >= $rule->rule_value;
}
- my $reserves_control_branch =
- GetReservesControlBranch( $item->unblessed(), $borrower );
my $branchitemrule =
C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->effective_itemtype );
my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
if ( $branchitemrule->{holdallowed} eq 'from_local_hold_group') {
- if($borrower->{branchcode} ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $borrower->{branchcode}} )) {
+ if($patron->branchcode ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $patron->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')
- and !C4::Context->preference('canreservefromotherbranches') )
- {
- if ( $item->homebranch ne $borrower->{branchcode} ) {
- return { status => 'cannotReserveFromOtherBranches' };
- }
- }
-
if ($pickup_branchcode) {
my $destination = Koha::Libraries->find({
branchcode => $pickup_branchcode,
my ( $notissued, $reserved );
( $notissued ) = $dbh->selectrow_array( $issue_qry, undef,
( $biblionumber ) );
- if( $notissued ) {
+ if( $notissued == 0 ) {
+ # all items are issued
( $reserved ) = $dbh->selectrow_array( $holds_qry, undef,
( $biblionumber, $borrowernumber ) );
$fee = 0 if $reserved == 0;
+ } else {
+ $fee = 0;
}
}
return $fee;
my $expireWaiting = C4::Context->preference('ExpireReservesMaxPickUpDelay');
my $dtf = Koha::Database->new->schema->storage->datetime_parser;
- my $params = { expirationdate => { '<', $dtf->format_date($today) } };
+ my $params = {
+ -or => [
+ { expirationdate => { '<', $dtf->format_date($today) } },
+ { patron_expiration_date => { '<' => $dtf->format_date($today) } }
+ ]
+ };
+
$params->{found} = [ { '!=', 'W' }, undef ] unless $expireWaiting;
# FIXME To move to Koha::Holds->search_expired (?)
if ( defined($hold->found) && $hold->found eq 'W' ) {
$cancel_params->{charge_cancel_fee} = 1;
}
+ $cancel_params->{autofill} = C4::Context->preference('ExpireReservesAutoFill');
$hold->cancel( $cancel_params );
}
}
sub AutoUnsuspendReserves {
my $today = dt_from_string();
- my @holds = Koha::Holds->search( { suspend_until => { '<=' => $today->ymd() } } );
+ my @holds = Koha::Holds->search( { suspend_until => { '<=' => $today->ymd() } } )->as_list;
map { $_->resume() } @holds;
}
priority to a non-zero value also sets the request's found
status and waiting date to NULL.
+If the hold is 'found' (waiting, in-transit, processing) the
+only field that can be updated is the expiration date.
+
The optional C<$itemnumber> parameter is used only when
C<$rank> is a non-zero integer; if supplied, the itemnumber
of the hold request is set accordingly; if omitted, the itemnumber
my $borrowernumber = $params->{'borrowernumber'};
my $biblionumber = $params->{'biblionumber'};
my $cancellation_reason = $params->{'cancellation_reason'};
+ my $date = $params->{expirationdate};
- return if $rank eq "n";
+ return if defined $rank && $rank eq "n";
return unless ( $reserve_id || ( $borrowernumber && ( $biblionumber || $itemnumber ) ) );
$hold ||= Koha::Holds->find($reserve_id);
+ # FIXME Other calls may fail
+ Koha::Exceptions::ObjectNotFound->throw( 'No hold with id ' . $reserve_id ) unless $hold;
+
if ( $rank eq "del" ) {
$hold->cancel({ cancellation_reason => $cancellation_reason });
}
- elsif ($hold->found && $hold->priority eq '0') {
- logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->unblessed) )
+ elsif ($hold->found && $hold->priority eq '0' && $date) {
+ logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
if C4::Context->preference('HoldsLog');
# The only column that can be updated for a found hold is the expiration date
- my $date = $params->{expirationdate};
- if ($date) {
- $hold->expirationdate(dt_from_string($date))->store();
- }
+ $hold->expirationdate($date)->store();
}
elsif ($rank =~ /^\d+/ and $rank > 0) {
- logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->unblessed) )
+ logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
if C4::Context->preference('HoldsLog');
my $properties = {
if ( defined( $suspend_until ) ) {
if ( $suspend_until ) {
- $suspend_until = eval { dt_from_string( $suspend_until ) };
$hold->suspend_hold( $suspend_until );
} else {
# If the hold is suspended leave the hold suspended, but convert it to an indefinite hold.
}
}
-=head2 ModReserveFill
-
- &ModReserveFill($reserve);
-
-Fill a reserve. If I understand this correctly, this means that the
-reserved book has been found and given to the patron who reserved it.
-
-C<$reserve> specifies the reserve to fill. It is a reference-to-hash
-whose keys are fields from the reserves table in the Koha database.
-
-=cut
-
-sub ModReserveFill {
- my ($res) = @_;
- my $reserve_id = $res->{'reserve_id'};
-
- my $hold = Koha::Holds->find($reserve_id);
- # get the priority on this record....
- my $priority = $hold->priority;
-
- # update the hold statuses, no need to store it though, we will be deleting it anyway
- $hold->set(
- {
- found => 'F',
- priority => 0,
- }
- );
-
- logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->unblessed) )
- if C4::Context->preference('HoldsLog');
-
- # FIXME Must call Koha::Hold->cancel ? => No, should call ->filled and add the correct log
- Koha::Old::Hold->new( $hold->unblessed() )->store();
-
- $hold->delete();
-
- if ( C4::Context->preference('HoldFeeMode') eq 'any_time_is_collected' ) {
- my $reserve_fee = GetReserveFee( $hold->borrowernumber, $hold->biblionumber );
- ChargeReserveFee( $hold->borrowernumber, $reserve_fee, $hold->biblio->title );
- }
-
- # now fix the priority on the others (if the priority wasn't
- # already sorted!)....
- unless ( $priority == 0 ) {
- _FixPriority( { reserve_id => $reserve_id, biblionumber => $hold->biblionumber } );
- }
-}
-
=head2 ModReserveStatus
&ModReserveStatus($itemnumber, $newstatus);
=head2 ModReserveAffect
- &ModReserveAffect($itemnumber,$borrowernumber,$diffBranchSend,$reserve_id, $desk_id);
+ &ModReserveAffect($itemnumber,$borrowernumber,$diffBranchSend,$reserve_id, $desk_id, $notify_library);
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
=cut
sub ModReserveAffect {
- my ( $itemnumber, $borrowernumber, $transferToDo, $reserve_id, $desk_id ) = @_;
+ my ( $itemnumber, $borrowernumber, $transferToDo, $reserve_id, $desk_id, $notify_library ) = @_;
my $dbh = C4::Context->dbh;
# we want to attach $itemnumber to $borrowernumber, find the biblionumber
$transfer->receive if $transfer;
}
+ _koha_notify_hold_changed( $hold ) if $notify_library;
+
_FixPriority( { biblionumber => $biblionumber } );
my $item = Koha::Items->find($itemnumber);
if ( $item->location && $item->location eq 'CART'
});
$std->execute($hold->reserve_id);
- logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->get_from_storage->unblessed) )
+ logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
if C4::Context->preference('HoldsLog');
return;
# or something similar - need to be
# consolidated
my $itemtype = $item->effective_itemtype;
+ return 0
+ unless defined $itemtype;
my $notforloan_per_itemtype = Koha::ItemTypes->find($itemtype)->notforloan;
return 0 if
sub ItemsAnyAvailableAndNotRestricted {
my $param = shift;
- my @items = Koha::Items->search( { biblionumber => $param->{biblionumber} } );
+ my @items = Koha::Items->search( { biblionumber => $param->{biblionumber} } )->as_list;
foreach my $i (@items) {
my $reserves_control_branch =
|| Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
|| $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';
+ || CanItemBeReserved( $param->{patron}, $i )->{status} ne 'OK';
}
return 0;
_FixPriority({ reserve_id => $reserve_id, rank => $last_priority });
}
+ Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
+ {
+ biblio_ids => [ $hold->biblionumber ]
+ }
+ ) if C4::Context->preference('RealTimeHoldsQueue');
# FIXME Should return the new priority
}
sub ToggleSuspend {
my ( $reserve_id, $suspend_until ) = @_;
- $suspend_until = dt_from_string($suspend_until) if ($suspend_until);
-
my $hold = Koha::Holds->find( $reserve_id );
if ( $hold->is_suspended ) {
my $suspend_until = $params{'suspend_until'} || undef;
my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;
- $suspend_until = eval { dt_from_string($suspend_until) }
- if ( defined($suspend_until) );
-
return unless ( $borrowernumber || $biblionumber );
my $params;
$params->{borrowernumber} = $borrowernumber if $borrowernumber;
$params->{biblionumber} = $biblionumber if $biblionumber;
- my @holds = Koha::Holds->search($params);
+ my @holds = Koha::Holds->search($params)->as_list;
if ($suspend) {
map { $_->suspend_hold($suspend_until) } @holds;
_koha_notify_reserve( $hold->reserve_id );
Sends a notification to the patron that their hold has been filled (through
-ModReserveAffect, _not_ ModReserveFill)
+ModReserveAffect)
The letter code for this notice may be found using the following query:
sub _koha_notify_reserve {
my $reserve_id = shift;
+
my $hold = Koha::Holds->find($reserve_id);
my $borrowernumber = $hold->borrowernumber;
} );
my $library = Koha::Libraries->find( $hold->branchcode );
- my $admin_email_address = $library->from_email_address;
- $library = $library->unblessed;
+ my $inbound_email_address = $library->inbound_email_address;
my %letter_params = (
module => 'reserves',
branchcode => $hold->branchcode,
lang => $patron->lang,
tables => {
- 'branches' => $library,
+ 'branches' => $library->unblessed,
'borrowers' => $patron->unblessed,
'biblio' => $hold->biblionumber,
'biblioitems' => $hold->biblionumber,
C4::Letters::EnqueueLetter( {
letter => $letter,
borrowernumber => $borrowernumber,
- from_address => $admin_email_address,
+ from_address => $inbound_email_address,
message_transport_type => $mtt,
} );
};
}
-=head2 _ShiftPriorityByDateAndPriority
+=head2 _koha_notify_hold_changed
+
+ _koha_notify_hold_changed( $hold_object );
- $new_priority = _ShiftPriorityByDateAndPriority( $biblionumber, $reservedate, $priority );
+=cut
+
+sub _koha_notify_hold_changed {
+ my $hold = shift;
+
+ my $patron = $hold->patron;
+ my $library = $hold->branch;
+
+ my $letter = C4::Letters::GetPreparedLetter(
+ module => 'reserves',
+ letter_code => 'HOLD_CHANGED',
+ branchcode => $hold->branchcode,
+ substitute => { today => output_pref( dt_from_string ) },
+ tables => {
+ 'branches' => $library->unblessed,
+ 'borrowers' => $patron->unblessed,
+ 'biblio' => $hold->biblionumber,
+ 'biblioitems' => $hold->biblionumber,
+ 'reserves' => $hold->unblessed,
+ 'items' => $hold->itemnumber,
+ },
+ );
+
+ return unless $letter;
+
+ my $email =
+ C4::Context->preference('ExpireReservesAutoFillEmail')
+ || $library->inbound_email_address;
+
+ C4::Letters::EnqueueLetter(
+ {
+ letter => $letter,
+ borrowernumber => $patron->id,
+ message_transport_type => 'email',
+ from_address => $email,
+ to_address => $email,
+ }
+ );
+}
+
+=head2 _ShiftPriority
+
+ $new_priority = _ShiftPriority( $biblionumber, $priority );
This increments the priority of all reserves after the one
with either the lowest date after C<$reservedate>
=cut
-sub _ShiftPriorityByDateAndPriority {
- my ( $biblio, $resdate, $new_priority ) = @_;
+sub _ShiftPriority {
+ my ( $biblio, $new_priority ) = @_;
my $dbh = C4::Context->dbh;
- my $query = "SELECT priority FROM reserves WHERE biblionumber = ? AND ( reservedate > ? OR priority > ? ) ORDER BY priority ASC LIMIT 1";
+ my $query = "SELECT priority FROM reserves WHERE biblionumber = ? AND priority > ? ORDER BY priority ASC LIMIT 1";
my $sth = $dbh->prepare( $query );
- $sth->execute( $biblio, $resdate, $new_priority );
+ $sth->execute( $biblio, $new_priority );
my $min_priority = $sth->fetchrow;
# if no such matches are found, $new_priority remains as original value
$new_priority = $min_priority if ( $min_priority );
my ( $restype, $res, undef ) = CheckReserves( $itemnumber, undef, $lookahead );
return unless $res;
- my $biblionumber = $res->{biblionumber};
+ my $biblionumber = $res->{biblionumber};
if ($res->{borrowernumber} == $borrowernumber) {
- ModReserveFill($res);
+ my $hold = Koha::Holds->find( $res->{reserve_id} );
+ $hold->fill;
}
else {
# warn "Reserved";
if ( $borr_res ) {
# The item is reserved by the current patron
- ModReserveFill($borr_res->unblessed);
+ $borr_res->fill;
}
if ( $cancelreserve eq 'revert' ) { ## Revert waiting reserve to priority 1
priority => 1,
found => undef,
waitingdate => undef,
+ expirationdate => $hold->patron_expiration_date,
itemnumber => $hold->item_level_hold ? $hold->itemnumber : undef,
}
)->store();
_FixPriority( { biblionumber => $hold->biblionumber } );
+ Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
+ {
+ biblio_ids => [ $hold->biblionumber ]
+ }
+ ) if C4::Context->preference('RealTimeHoldsQueue');
+
+
return $hold;
}
the parameter value.
After calculation of this priority, it is recommended to call
-_ShiftPriorityByDateAndPriority. Note that this is currently done in
+_ShiftPriority. Note that this is currently done in
AddReserves.
=cut
my ( $borrowernumber, $biblionumber ) = @_;
my $patron = Koha::Patrons->find($borrowernumber);
- my @items = Koha::Items->search( { biblionumber => $biblionumber } );
+ my @items = Koha::Items->search( { biblionumber => $biblionumber } )->as_list;
my $controlbranch = C4::Context->preference('ReservesControlBranch');
projects / koha-ffzg.git / blobdiff