C4/Reserves.pm

   1 package C4::Reserves;
   2
   3 # Copyright 2000-2002 Katipo Communications
   4 #           2006 SAN Ouest Provence
   5 #           2007-2010 BibLibre Paul POULAIN
   6 #           2011 Catalyst IT
   7 #
   8 # This file is part of Koha.
   9 #
  10 # Koha is free software; you can redistribute it and/or modify it
  11 # under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 3 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # Koha is distributed in the hope that it will be useful, but
  16 # WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  22
  23
  24 use Modern::Perl;
  25
  26 use C4::Accounts;
  27 use C4::Biblio qw( GetMarcFromKohaField );
  28 use C4::Circulation qw( CheckIfIssuedToPatron GetAgeRestriction GetBranchItemRule );
  29 use C4::Context;
  30 use C4::Items qw( CartToShelf get_hostitemnumbers_of );
  31 use C4::Letters;
  32 use C4::Log qw( logaction );
  33 use C4::Members::Messaging;
  34 use C4::Members;
  35 use Koha::Account::Lines;
  36 use Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue;
  37 use Koha::Biblios;
  38 use Koha::Calendar;
  39 use Koha::CirculationRules;
  40 use Koha::Database;
  41 use Koha::DateUtils qw( dt_from_string output_pref );
  42 use Koha::Holds;
  43 use Koha::ItemTypes;
  44 use Koha::Items;
  45 use Koha::Libraries;
  46 use Koha::Old::Holds;
  47 use Koha::Patrons;
  48 use Koha::Plugins;
  49
  50 use List::MoreUtils qw( any );
  51
  52 =head1 NAME
  53
  54 C4::Reserves - Koha functions for dealing with reservation.
  55
  56 =head1 SYNOPSIS
  57
  58   use C4::Reserves;
  59
  60 =head1 DESCRIPTION
  61
  62 This modules provides somes functions to deal with reservations.
  63
  64   Reserves are stored in reserves table.
  65   The following columns contains important values :
  66   - priority >0      : then the reserve is at 1st stage, and not yet affected to any item.
  67              =0      : then the reserve is being dealed
  68   - found : NULL         : means the patron requested the 1st available, and we haven't chosen the item
  69             T(ransit)    : the reserve is linked to an item but is in transit to the pickup branch
  70             W(aiting)    : the reserve is linked to an item, is at the pickup branch, and is waiting on the hold shelf
  71             F(inished)   : the reserve has been completed, and is done
  72             P(rocessing) : reserved item has been returned using self-check machine and reserve needs to be confirmed
  73                            by librarian before notice is send and status changed to waiting.
  74                            Applicable only if HoldsNeedProcessingSIP system preference is set.
  75   - itemnumber : empty : the reserve is still unaffected to an item
  76                  filled: the reserve is attached to an item
  77   The complete workflow is :
  78   ==== 1st use case ====
  79   patron request a document, 1st available :                      P >0, F=NULL, I=NULL
  80   a library having it run "transfertodo", and clic on the list
  81          if there is no transfer to do, the reserve waiting
  82          patron can pick it up                                    P =0, F=W,    I=filled
  83          if there is a transfer to do, write in branchtransfer    P =0, F=T,    I=filled
  84            The pickup library receive the book, it check in       P =0, F=W,    I=filled
  85   The patron borrow the book                                      P =0, F=F,    I=filled
  86
  87   ==== 2nd use case ====
  88   patron requests a document, a given item,
  89     If pickup is holding branch                                   P =0, F=W,   I=filled
  90     If transfer needed, write in branchtransfer                   P =0, F=T,    I=filled
  91         The pickup library receive the book, it checks it in      P =0, F=W,    I=filled
  92   The patron borrow the book                                      P =0, F=F,    I=filled
  93
  94 =head1 FUNCTIONS
  95
  96 =cut
  97
  98 our (@ISA, @EXPORT_OK);
  99 BEGIN {
 100     require Exporter;
 101     @ISA = qw(Exporter);
 102     @EXPORT_OK = qw(
 103       AddReserve
 104
 105       GetReserveStatus
 106
 107       GetOtherReserves
 108       ChargeReserveFee
 109       GetReserveFee
 110
 111       ModReserveAffect
 112       ModReserve
 113       ModReserveStatus
 114       ModReserveCancelAll
 115       ModReserveMinusPriority
 116       MoveReserve
 117
 118       CheckReserves
 119       CanBookBeReserved
 120       CanItemBeReserved
 121       CanReserveBeCanceledFromOpac
 122       CancelExpiredReserves
 123
 124       AutoUnsuspendReserves
 125
 126       IsAvailableForItemLevelRequest
 127       ItemsAnyAvailableAndNotRestricted
 128
 129       AlterPriority
 130       ToggleLowestPriority
 131
 132       ReserveSlip
 133       ToggleSuspend
 134       SuspendAll
 135
 136       GetReservesControlBranch
 137
 138       CalculatePriority
 139
 140       IsItemOnHoldAndFound
 141
 142       GetMaxPatronHoldsForRecord
 143
 144       MergeHolds
 145
 146       RevertWaitingStatus
 147     );
 148 }
 149
 150 =head2 AddReserve
 151
 152     AddReserve(
 153         {
 154             branchcode       => $branchcode,
 155             borrowernumber   => $borrowernumber,
 156             biblionumber     => $biblionumber,
 157             priority         => $priority,
 158             reservation_date => $reservation_date,
 159             expiration_date  => $expiration_date,
 160             notes            => $notes,
 161             title            => $title,
 162             itemnumber       => $itemnumber,
 163             found            => $found,
 164             itemtype         => $itemtype,
 165             item_gorup_id    => $item_group_id
 166         }
 167     );
 168
 169 Adds reserve and generates HOLDPLACED message.
 170
 171 The following tables are available witin the HOLDPLACED message:
 172
 173     branches
 174     borrowers
 175     biblio
 176     biblioitems
 177     items
 178     reserves
 179
 180 =cut
 181
 182 sub AddReserve {
 183     my ($params)       = @_;
 184     my $branch         = $params->{branchcode};
 185     my $borrowernumber = $params->{borrowernumber};
 186     my $biblionumber   = $params->{biblionumber};
 187     my $priority       = $params->{priority};
 188     my $resdate        = $params->{reservation_date};
 189     my $patron_expiration_date = $params->{expiration_date};
 190     my $notes          = $params->{notes};
 191     my $title          = $params->{title};
 192     my $checkitem      = $params->{itemnumber};
 193     my $found          = $params->{found};
 194     my $itemtype       = $params->{itemtype};
 195     my $non_priority   = $params->{non_priority};
 196     my $item_group_id  = $params->{item_group_id};
 197
 198     $resdate ||= dt_from_string;
 199
 200     # if we have an item selectionned, and the pickup branch is the same as the holdingbranch
 201     # of the document, we force the value $priority and $found .
 202     if ( $checkitem and not C4::Context->preference('ReservesNeedReturns') ) {
 203         my $item = Koha::Items->find( $checkitem ); # FIXME Prevent bad calls
 204
 205         if (
 206             # If item is already checked out, it cannot be set waiting
 207             !$item->onloan
 208
 209             # The item can't be waiting if it needs a transfer
 210             && $item->holdingbranch eq $branch
 211
 212             # Similarly, if in transit it can't be waiting
 213             && !$item->get_transfer
 214
 215             # If we can't hold damaged items, and it is damaged, it can't be waiting
 216             && ( $item->damaged && C4::Context->preference('AllowHoldsOnDamagedItems') || !$item->damaged )
 217
 218             # Lastly, if this already has holds, we shouldn't make it waiting for the new hold
 219             && !$item->current_holds->count )
 220         {
 221             $priority = 0;
 222             $found = 'W';
 223         }
 224     }
 225     if ( C4::Context->preference( 'AllowHoldDateInFuture' ) ) {
 226     # Make room in reserves for this if passed a priority
 227     $priority = _ShiftPriority( $biblionumber, $priority );
 228     }
 229
 230     my $waitingdate;
 231
 232     # If the reserv had the waiting status, we had the value of the resdate
 233     if ( $found && $found eq 'W' ) {
 234         $waitingdate = $resdate;
 235     }
 236
 237     # Don't add itemtype limit if specific item is selected
 238     $itemtype = undef if $checkitem;
 239
 240     # updates take place here
 241     my $hold = Koha::Hold->new(
 242         {
 243             borrowernumber => $borrowernumber,
 244             biblionumber   => $biblionumber,
 245             item_group_id  => $item_group_id,
 246             reservedate    => $resdate,
 247             branchcode     => $branch,
 248             priority       => $priority,
 249             reservenotes   => $notes,
 250             itemnumber     => $checkitem,
 251             found          => $found,
 252             waitingdate    => $waitingdate,
 253             patron_expiration_date => $patron_expiration_date,
 254             itemtype       => $itemtype,
 255             item_level_hold => $checkitem ? 1 : 0,
 256             non_priority   => $non_priority ? 1 : 0,
 257         }
 258     )->store();
 259     $hold->set_waiting() if $found && $found eq 'W';
 260
 261     logaction( 'HOLDS', 'CREATE', $hold->id, $hold )
 262         if C4::Context->preference('HoldsLog');
 263
 264     my $reserve_id = $hold->id();
 265
 266     # add a reserve fee if needed
 267     if ( C4::Context->preference('HoldFeeMode') ne 'any_time_is_collected' ) {
 268         my $reserve_fee = GetReserveFee( $borrowernumber, $biblionumber );
 269         ChargeReserveFee( $borrowernumber, $reserve_fee, $title );
 270     }
 271
 272     _FixPriority({ biblionumber => $biblionumber});
 273
 274     # Send e-mail to librarian if syspref is active
 275     if(C4::Context->preference("emailLibrarianWhenHoldIsPlaced")){
 276         my $patron = Koha::Patrons->find( $borrowernumber );
 277         my $library = $patron->library;
 278         if ( my $letter =  C4::Letters::GetPreparedLetter (
 279             module => 'reserves',
 280             letter_code => 'HOLDPLACED',
 281             branchcode => $branch,
 282             lang => $patron->lang,
 283             tables => {
 284                 'branches'    => $library->unblessed,
 285                 'borrowers'   => $patron->unblessed,
 286                 'biblio'      => $biblionumber,
 287                 'biblioitems' => $biblionumber,
 288                 'items'       => $checkitem,
 289                 'reserves'    => $hold->unblessed,
 290             },
 291         ) ) {
 292
 293             my $branch_email_address = $library->inbound_email_address;
 294
 295             C4::Letters::EnqueueLetter(
 296                 {
 297                     letter                 => $letter,
 298                     borrowernumber         => $borrowernumber,
 299                     message_transport_type => 'email',
 300                     to_address             => $branch_email_address,
 301                 }
 302             );
 303         }
 304     }
 305
 306     Koha::Plugins->call('after_hold_create', $hold);
 307     Koha::Plugins->call(
 308         'after_hold_action',
 309         {
 310             action  => 'place',
 311             payload => { hold => $hold->get_from_storage }
 312         }
 313     );
 314
 315     Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
 316         {
 317             biblio_ids => [ $biblionumber ]
 318         }
 319     ) if C4::Context->preference('RealTimeHoldsQueue');
 320
 321     return $reserve_id;
 322 }
 323
 324 =head2 CanBookBeReserved
 325
 326   $canReserve = &CanBookBeReserved($borrowernumber, $biblionumber, $branchcode, $params)
 327   if ($canReserve eq 'OK') { #We can reserve this Item! }
 328
 329   $params are passed directly through to CanItemBeReserved
 330
 331 See CanItemBeReserved() for possible return values.
 332
 333 =cut
 334
 335 sub CanBookBeReserved{
 336     my ($borrowernumber, $biblionumber, $pickup_branchcode, $params) = @_;
 337
 338     # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
 339     if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
 340         && C4::Circulation::CheckIfIssuedToPatron( $borrowernumber, $biblionumber ) ) {
 341         return { status =>'alreadypossession' };
 342     }
 343
 344     if ( $params->{itemtype} ) {
 345
 346         # biblio-level, item type-contrained
 347         my $patron          = Koha::Patrons->find($borrowernumber);
 348         my $reservesallowed = Koha::CirculationRules->get_effective_rule(
 349             {
 350                 itemtype     => $params->{itemtype},
 351                 categorycode => $patron->categorycode,
 352                 branchcode   => $pickup_branchcode,
 353                 rule_name    => 'reservesallowed',
 354             }
 355         )->rule_value;
 356
 357         $reservesallowed = ( $reservesallowed eq '' ) ? undef : $reservesallowed;
 358
 359         my $count = $patron->holds->search(
 360             {
 361                 '-or' => [
 362                     { 'me.itemtype' => $params->{itemtype} },
 363                     { 'item.itype'  => $params->{itemtype} }
 364                 ]
 365             },
 366             {
 367                 join => ['item']
 368             }
 369         )->count;
 370
 371         return { status => '' }
 372           if defined $reservesallowed and $reservesallowed < $count + 1;
 373     }
 374
 375     my $items;
 376     #get items linked via host records
 377     my @hostitemnumbers = get_hostitemnumbers_of($biblionumber);
 378     if (@hostitemnumbers){
 379         $items = Koha::Items->search({
 380             -or => [
 381                 biblionumber => $biblionumber,
 382                 itemnumber => { -in => @hostitemnumbers }
 383             ]
 384         });
 385     } else {
 386         $items = Koha::Items->search({ biblionumber => $biblionumber});
 387     }
 388
 389     my $canReserve = { status => '' };
 390     my $patron = Koha::Patrons->find( $borrowernumber );
 391     while ( my $item = $items->next ) {
 392         $canReserve = CanItemBeReserved( $patron, $item, $pickup_branchcode, $params );
 393         return { status => 'OK' } if $canReserve->{status} eq 'OK';
 394     }
 395     return $canReserve;
 396 }
 397
 398 =head2 CanItemBeReserved
 399
 400   $canReserve = &CanItemBeReserved($patron, $item, $branchcode, $params)
 401   if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }
 402
 403   current params are:
 404   'ignore_hold_counts' - we use this routine to check if an item can fill a hold - on this case we
 405   should not check if there are too many holds as we only care about reservability
 406
 407 @RETURNS { status => OK },              if the Item can be reserved.
 408          { status => ageRestricted },   if the Item is age restricted for this borrower.
 409          { status => damaged },         if the Item is damaged.
 410          { status => cannotReserveFromOtherBranches }, if syspref 'canreservefromotherbranches' is OK.
 411          { status => branchNotInHoldGroup }, if borrower home library is not in hold group, and holds are only allowed from hold groups.
 412          { status => tooManyReserves, limit => $limit }, if the borrower has exceeded their maximum reserve amount.
 413          { status => notReservable },   if holds on this item are not allowed
 414          { status => libraryNotFound },   if given branchcode is not an existing library
 415          { status => libraryNotPickupLocation },   if given branchcode is not configured to be a pickup location
 416          { status => cannotBeTransferred }, if branch transfer limit applies on given item and branchcode
 417          { status => pickupNotInHoldGroup }, pickup location is not in hold group, and pickup locations are only allowed from hold groups.
 418          { status => recall }, if the borrower has already placed a recall on this item
 419
 420 =cut
 421
 422 sub CanItemBeReserved {
 423     my ( $patron, $item, $pickup_branchcode, $params ) = @_;
 424
 425     my $dbh = C4::Context->dbh;
 426     my $ruleitemtype;    # itemtype of the matching issuing rule
 427     my $allowedreserves  = 0; # Total number of holds allowed across all records, default to none
 428
 429     # We check item branch if IndependentBranches is ON
 430     # and canreservefromotherbranches is OFF
 431     if ( C4::Context->preference('IndependentBranches')
 432         and !C4::Context->preference('canreservefromotherbranches') )
 433     {
 434         if ( $item->homebranch ne $patron->branchcode ) {
 435             return { status => 'cannotReserveFromOtherBranches' };
 436         }
 437     }
 438
 439     # we retrieve borrowers and items informations #
 440     # item->{itype} will come for biblioitems if necessery
 441     my $borrower = $patron->unblessed;
 442
 443     # If an item is damaged and we don't allow holds on damaged items, we can stop right here
 444     return { status =>'damaged' }
 445       if ( $item->damaged
 446         && !C4::Context->preference('AllowHoldsOnDamagedItems') );
 447
 448     if( GetMarcFromKohaField('biblioitems.agerestriction') ){
 449         my $biblio = $item->biblio;
 450         # Check for the age restriction
 451         my ( $ageRestriction, $daysToAgeRestriction ) =
 452           C4::Circulation::GetAgeRestriction( $biblio->biblioitem->agerestriction, $borrower );
 453         return { status => 'ageRestricted' } if $daysToAgeRestriction && $daysToAgeRestriction > 0;
 454     }
 455
 456     # Check that the patron doesn't have an item level hold on this item already
 457     return { status =>'itemAlreadyOnHold' }
 458       if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $patron->borrowernumber, itemnumber => $item->itemnumber } )->count() );
 459
 460     # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
 461     if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
 462         && C4::Circulation::CheckIfIssuedToPatron( $patron->borrowernumber, $item->biblionumber ) ) {
 463         return { status =>'alreadypossession' };
 464     }
 465
 466     # check if a recall exists on this item from this borrower
 467     return { status => 'recall' }
 468       if $patron->recalls->filter_by_current->search({ item_id => $item->itemnumber })->count;
 469
 470     my $controlbranch = C4::Context->preference('ReservesControlBranch');
 471
 472     my $reserves_control_branch;
 473     my $branchfield = "reserves.branchcode";
 474
 475     if ( $controlbranch eq "ItemHomeLibrary" ) {
 476         $branchfield = "items.homebranch";
 477         $reserves_control_branch  = $item->homebranch;
 478     }
 479     elsif ( $controlbranch eq "PatronLibrary" ) {
 480         $branchfield = "borrowers.branchcode";
 481         $reserves_control_branch  = $borrower->{branchcode};
 482     }
 483
 484     # we retrieve rights
 485     if (
 486         my $reservesallowed = Koha::CirculationRules->get_effective_rule({
 487                 itemtype     => $item->effective_itemtype,
 488                 categorycode => $borrower->{categorycode},
 489                 branchcode   => $reserves_control_branch,
 490                 rule_name    => 'reservesallowed',
 491         })
 492     ) {
 493         $ruleitemtype     = $reservesallowed->itemtype;
 494         $allowedreserves  = $reservesallowed->rule_value // 0; #undefined is 0, blank is unlimited
 495     }
 496     else {
 497         $ruleitemtype = undef;
 498     }
 499
 500     my $rights = Koha::CirculationRules->get_effective_rules({
 501         categorycode => $borrower->{'categorycode'},
 502         itemtype     => $item->effective_itemtype,
 503         branchcode   => $reserves_control_branch,
 504         rules        => ['holds_per_record','holds_per_day']
 505     });
 506     my $holds_per_record = $rights->{holds_per_record} // 1;
 507     my $holds_per_day    = $rights->{holds_per_day};
 508
 509     if (   defined $holds_per_record && $holds_per_record ne '' ){
 510         if ( $holds_per_record == 0 ) {
 511             return { status => "noReservesAllowed" };
 512         }
 513         if ( !$params->{ignore_hold_counts} ) {
 514             my $search_params = {
 515                 borrowernumber => $patron->borrowernumber,
 516                 biblionumber   => $item->biblionumber,
 517             };
 518             my $holds = Koha::Holds->search($search_params);
 519             return { status => "tooManyHoldsForThisRecord", limit => $holds_per_record } if $holds->count() >= $holds_per_record;
 520         }
 521     }
 522
 523     if (!$params->{ignore_hold_counts} && defined $holds_per_day && $holds_per_day ne '')
 524     {
 525         my $today_holds = Koha::Holds->search({
 526             borrowernumber => $patron->borrowernumber,
 527             reservedate    => dt_from_string->date
 528         });
 529         return { status => 'tooManyReservesToday', limit => $holds_per_day } if $today_holds->count() >= $holds_per_day;
 530     }
 531
 532     # we check if it's ok or not
 533     if ( defined $allowedreserves && $allowedreserves ne '' ){
 534         if( $allowedreserves == 0 ){
 535             return { status => 'noReservesAllowed' };
 536         }
 537         if ( !$params->{ignore_hold_counts} ) {
 538             # we retrieve count
 539             my $querycount = q{
 540                 SELECT count(*) AS count
 541                   FROM reserves
 542              LEFT JOIN items USING (itemnumber)
 543              LEFT JOIN biblioitems ON (reserves.biblionumber=biblioitems.biblionumber)
 544              LEFT JOIN borrowers USING (borrowernumber)
 545                  WHERE borrowernumber = ?
 546             };
 547             $querycount .= "AND ( $branchfield = ? OR $branchfield IS NULL )";
 548
 549             # If using item-level itypes, fall back to the record
 550             # level itemtype if the hold has no associated item
 551             if ( defined $ruleitemtype ) {
 552                 if ( C4::Context->preference('item-level_itypes') ) {
 553                     $querycount .= q{
 554                         AND ( COALESCE( items.itype, biblioitems.itemtype ) = ?
 555                            OR reserves.itemtype = ? )
 556                     };
 557                 }
 558                 else {
 559                     $querycount .= q{
 560                         AND ( biblioitems.itemtype = ?
 561                            OR reserves.itemtype = ? )
 562                     };
 563                 }
 564             }
 565
 566             my $sthcount = $dbh->prepare($querycount);
 567
 568             if ( defined $ruleitemtype ) {
 569                 $sthcount->execute( $patron->borrowernumber, $reserves_control_branch, $ruleitemtype, $ruleitemtype );
 570             }
 571             else {
 572                 $sthcount->execute( $patron->borrowernumber, $reserves_control_branch );
 573             }
 574
 575             my $reservecount = "0";
 576             if ( my $rowcount = $sthcount->fetchrow_hashref() ) {
 577                 $reservecount = $rowcount->{count};
 578             }
 579
 580             return { status => 'tooManyReserves', limit => $allowedreserves } if $reservecount >= $allowedreserves;
 581         }
 582     }
 583
 584     # Now we need to check hold limits by patron category
 585     my $rule = Koha::CirculationRules->get_effective_rule(
 586         {
 587             categorycode => $patron->categorycode,
 588             branchcode   => $reserves_control_branch,
 589             rule_name    => 'max_holds',
 590         }
 591     );
 592     if (!$params->{ignore_hold_counts} && $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
 593         my $total_holds_count = Koha::Holds->search(
 594             {
 595                 borrowernumber => $patron->borrowernumber
 596             }
 597         )->count();
 598
 599         return { status => 'tooManyReserves', limit => $rule->rule_value} if $total_holds_count >= $rule->rule_value;
 600     }
 601
 602     my $branchitemrule =
 603       C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->effective_itemtype );
 604
 605     if ( $branchitemrule->{holdallowed} eq 'not_allowed' ) {
 606         return { status => 'notReservable' };
 607     }
 608
 609     if (   $branchitemrule->{holdallowed} eq 'from_home_library'
 610         && $borrower->{branchcode} ne $item->homebranch )
 611     {
 612         return { status => 'cannotReserveFromOtherBranches' };
 613     }
 614
 615     my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
 616     if ( $branchitemrule->{holdallowed} eq 'from_local_hold_group') {
 617         if($patron->branchcode ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $patron->branchcode} )) {
 618             return { status => 'branchNotInHoldGroup' };
 619         }
 620     }
 621
 622     if ($pickup_branchcode) {
 623         my $destination = Koha::Libraries->find({
 624             branchcode => $pickup_branchcode,
 625         });
 626
 627         unless ($destination) {
 628             return { status => 'libraryNotFound' };
 629         }
 630         unless ($destination->pickup_location) {
 631             return { status => 'libraryNotPickupLocation' };
 632         }
 633         unless ($item->can_be_transferred({ to => $destination })) {
 634             return { status => 'cannotBeTransferred' };
 635         }
 636         if ($branchitemrule->{hold_fulfillment_policy} eq 'holdgroup' && !$item_library->validate_hold_sibling( {branchcode => $pickup_branchcode} )) {
 637             return { status => 'pickupNotInHoldGroup' };
 638         }
 639         if ($branchitemrule->{hold_fulfillment_policy} eq 'patrongroup' && !Koha::Libraries->find({branchcode => $borrower->{branchcode}})->validate_hold_sibling({branchcode => $pickup_branchcode})) {
 640             return { status => 'pickupNotInHoldGroup' };
 641         }
 642     }
 643
 644     return { status => 'OK' };
 645 }
 646
 647 =head2 CanReserveBeCanceledFromOpac
 648
 649     $number = CanReserveBeCanceledFromOpac($reserve_id, $borrowernumber);
 650
 651     returns 1 if reserve can be cancelled by user from OPAC.
 652     First check if reserve belongs to user, next checks if reserve is not in
 653     transfer or waiting status
 654
 655 =cut
 656
 657 sub CanReserveBeCanceledFromOpac {
 658     my ($reserve_id, $borrowernumber) = @_;
 659
 660     return unless $reserve_id and $borrowernumber;
 661     my $reserve = Koha::Holds->find($reserve_id) or return;
 662
 663     return 0 unless $reserve->borrowernumber == $borrowernumber;
 664     return $reserve->is_cancelable_from_opac;
 665 }
 666
 667 =head2 GetOtherReserves
 668
 669   ($messages,$nextreservinfo)=$GetOtherReserves(itemnumber);
 670
 671 Check queued list of this document and check if this document must be transferred
 672
 673 =cut
 674
 675 sub GetOtherReserves {
 676     my ($itemnumber) = @_;
 677     my $messages;
 678     my $nextreservinfo;
 679     my ( undef, $checkreserves, undef ) = CheckReserves($itemnumber);
 680     if ($checkreserves) {
 681         my $item = Koha::Items->find($itemnumber);
 682         if ( $item->holdingbranch ne $checkreserves->{'branchcode'} ) {
 683             $messages->{'transfert'} = $checkreserves->{'branchcode'};
 684             #minus priorities of others reservs
 685             ModReserveMinusPriority(
 686                 $itemnumber,
 687                 $checkreserves->{'reserve_id'},
 688             );
 689
 690             #launch the subroutine dotransfer
 691             C4::Items::ModItemTransfer(
 692                 $itemnumber,
 693                 $item->holdingbranch,
 694                 $checkreserves->{'branchcode'},
 695                 'Reserve'
 696               ),
 697               ;
 698         }
 699
 700      #step 2b : case of a reservation on the same branch, set the waiting status
 701         else {
 702             $messages->{'waiting'} = 1;
 703             ModReserveMinusPriority(
 704                 $itemnumber,
 705                 $checkreserves->{'reserve_id'},
 706             );
 707             ModReserveStatus($itemnumber,'W');
 708         }
 709
 710         $nextreservinfo = $checkreserves;
 711     }
 712
 713     return ( $messages, $nextreservinfo );
 714 }
 715
 716 =head2 ChargeReserveFee
 717
 718     $fee = ChargeReserveFee( $borrowernumber, $fee, $title );
 719
 720     Charge the fee for a reserve (if $fee > 0)
 721
 722 =cut
 723
 724 sub ChargeReserveFee {
 725     my ( $borrowernumber, $fee, $title ) = @_;
 726     return if !$fee || $fee == 0;    # the last test is needed to include 0.00
 727     Koha::Account->new( { patron_id => $borrowernumber } )->add_debit(
 728         {
 729             amount       => $fee,
 730             description  => $title,
 731             note         => undef,
 732             user_id      => C4::Context->userenv ? C4::Context->userenv->{'number'} : undef,
 733             library_id   => C4::Context->userenv ? C4::Context->userenv->{'branch'} : undef,
 734             interface    => C4::Context->interface,
 735             invoice_type => undef,
 736             type         => 'RESERVE',
 737             item_id      => undef
 738         }
 739     );
 740 }
 741
 742 =head2 GetReserveFee
 743
 744     $fee = GetReserveFee( $borrowernumber, $biblionumber );
 745
 746     Calculate the fee for a reserve (if applicable).
 747
 748 =cut
 749
 750 sub GetReserveFee {
 751     my ( $borrowernumber, $biblionumber ) = @_;
 752     my $borquery = qq{
 753 SELECT reservefee FROM borrowers LEFT JOIN categories ON borrowers.categorycode = categories.categorycode WHERE borrowernumber = ?
 754     };
 755     my $issue_qry = qq{
 756 SELECT COUNT(*) FROM items
 757 LEFT JOIN issues USING (itemnumber)
 758 WHERE items.biblionumber=? AND issues.issue_id IS NULL
 759     };
 760     my $holds_qry = qq{
 761 SELECT COUNT(*) FROM reserves WHERE biblionumber=? AND borrowernumber<>?
 762     };
 763
 764     my $dbh = C4::Context->dbh;
 765     my ( $fee ) = $dbh->selectrow_array( $borquery, undef, ($borrowernumber) );
 766     my $hold_fee_mode = C4::Context->preference('HoldFeeMode') || 'not_always';
 767     if( $fee and $fee > 0 and $hold_fee_mode eq 'not_always' ) {
 768         # This is a reconstruction of the old code:
 769         # Compare number of items with items issued, and optionally check holds
 770         # If not all items are issued and there are no holds: charge no fee
 771         # NOTE: Lost, damaged, not-for-loan, etc. are just ignored here
 772         my ( $notissued, $reserved );
 773         ( $notissued ) = $dbh->selectrow_array( $issue_qry, undef,
 774             ( $biblionumber ) );
 775         if( $notissued == 0 ) {
 776             # all items are issued
 777             ( $reserved ) = $dbh->selectrow_array( $holds_qry, undef,
 778                 ( $biblionumber, $borrowernumber ) );
 779             $fee = 0 if $reserved == 0;
 780         } else {
 781             $fee = 0;
 782         }
 783     }
 784     return $fee;
 785 }
 786
 787 =head2 GetReserveStatus
 788
 789   $reservestatus = GetReserveStatus($itemnumber);
 790
 791 Takes an itemnumber and returns the status of the reserve placed on it.
 792 If several reserves exist, the reserve with the lower priority is given.
 793
 794 =cut
 795
 796 ## FIXME: I don't think this does what it thinks it does.
 797 ## It only ever checks the first reserve result, even though
 798 ## multiple reserves for that bib can have the itemnumber set
 799 ## the sub is only used once in the codebase.
 800 sub GetReserveStatus {
 801     my ($itemnumber) = @_;
 802
 803     my $dbh = C4::Context->dbh;
 804
 805     my ($sth, $found, $priority);
 806     if ( $itemnumber ) {
 807         $sth = $dbh->prepare("SELECT found, priority FROM reserves WHERE itemnumber = ? order by priority LIMIT 1");
 808         $sth->execute($itemnumber);
 809         ($found, $priority) = $sth->fetchrow_array;
 810     }
 811
 812     if(defined $found) {
 813         return 'Waiting'  if $found eq 'W' and $priority == 0;
 814         return 'Processing'  if $found eq 'P';
 815         return 'Finished' if $found eq 'F';
 816     }
 817
 818     return 'Reserved' if defined $priority && $priority > 0;
 819
 820     return ''; # empty string here will remove need for checking undef, or less log lines
 821 }
 822
 823 =head2 CheckReserves
 824
 825   ($status, $matched_reserve, $possible_reserves) = &CheckReserves($itemnumber);
 826   ($status, $matched_reserve, $possible_reserves) = &CheckReserves(undef, $barcode);
 827   ($status, $matched_reserve, $possible_reserves) = &CheckReserves($itemnumber,undef,$lookahead);
 828
 829 Find a book in the reserves.
 830
 831 C<$itemnumber> is the book's item number.
 832 C<$lookahead> is the number of days to look in advance for future reserves.
 833
 834 As I understand it, C<&CheckReserves> looks for the given item in the
 835 reserves. If it is found, that's a match, and C<$status> is set to
 836 C<Waiting>.
 837
 838 Otherwise, it finds the most important item in the reserves with the
 839 same biblio number as this book (I'm not clear on this) and returns it
 840 with C<$status> set to C<Reserved>.
 841
 842 C<&CheckReserves> returns a two-element list:
 843
 844 C<$status> is either C<Waiting>, C<Reserved> (see above), or 0.
 845
 846 C<$reserve> is the reserve item that matched. It is a
 847 reference-to-hash whose keys are mostly the fields of the reserves
 848 table in the Koha database.
 849
 850 =cut
 851
 852 sub CheckReserves {
 853     my ( $item, $barcode, $lookahead_days, $ignore_borrowers) = @_;
 854     my $dbh = C4::Context->dbh;
 855     my $sth;
 856     my $select;
 857     if (C4::Context->preference('item-level_itypes')){
 858         $select = "
 859            SELECT items.biblionumber,
 860            items.biblioitemnumber,
 861            itemtypes.notforloan,
 862            items.notforloan AS itemnotforloan,
 863            items.itemnumber,
 864            items.damaged,
 865            items.homebranch,
 866            items.holdingbranch
 867            FROM   items
 868            LEFT JOIN biblioitems ON items.biblioitemnumber = biblioitems.biblioitemnumber
 869            LEFT JOIN itemtypes   ON items.itype   = itemtypes.itemtype
 870         ";
 871     }
 872     else {
 873         $select = "
 874            SELECT items.biblionumber,
 875            items.biblioitemnumber,
 876            itemtypes.notforloan,
 877            items.notforloan AS itemnotforloan,
 878            items.itemnumber,
 879            items.damaged,
 880            items.homebranch,
 881            items.holdingbranch
 882            FROM   items
 883            LEFT JOIN biblioitems ON items.biblioitemnumber = biblioitems.biblioitemnumber
 884            LEFT JOIN itemtypes   ON biblioitems.itemtype   = itemtypes.itemtype
 885         ";
 886     }
 887
 888     if ($item) {
 889         $sth = $dbh->prepare("$select WHERE itemnumber = ?");
 890         $sth->execute($item);
 891     }
 892     else {
 893         $sth = $dbh->prepare("$select WHERE barcode = ?");
 894         $sth->execute($barcode);
 895     }
 896     # note: we get the itemnumber because we might have started w/ just the barcode.  Now we know for sure we have it.
 897     my ( $biblio, $bibitem, $notforloan_per_itemtype, $notforloan_per_item, $itemnumber, $damaged, $item_homebranch, $item_holdingbranch ) = $sth->fetchrow_array;
 898     return if ( $damaged && !C4::Context->preference('AllowHoldsOnDamagedItems') );
 899
 900     return unless $itemnumber; # bail if we got nothing.
 901     # if item is not for loan it cannot be reserved either.....
 902     # except where items.notforloan < 0 :  This indicates the item is holdable.
 903
 904     my @SkipHoldTrapOnNotForLoanValue = split( '\|', C4::Context->preference('SkipHoldTrapOnNotForLoanValue') );
 905     return if grep { $_ eq $notforloan_per_item } @SkipHoldTrapOnNotForLoanValue;
 906
 907     my $dont_trap = C4::Context->preference('TrapHoldsOnOrder') ? ($notforloan_per_item > 0) : ($notforloan_per_item && 1 );
 908     return if $dont_trap or $notforloan_per_itemtype;
 909
 910     # Find this item in the reserves
 911     my @reserves = _Findgroupreserve( $bibitem, $biblio, $itemnumber, $lookahead_days, $ignore_borrowers);
 912
 913     # $priority and $highest are used to find the most important item
 914     # in the list returned by &_Findgroupreserve. (The lower $priority,
 915     # the more important the item.)
 916     # $highest is the most important item we've seen so far.
 917     my $highest;
 918
 919     if (scalar @reserves) {
 920         my $LocalHoldsPriority = C4::Context->preference('LocalHoldsPriority');
 921         my $LocalHoldsPriorityPatronControl = C4::Context->preference('LocalHoldsPriorityPatronControl');
 922         my $LocalHoldsPriorityItemControl = C4::Context->preference('LocalHoldsPriorityItemControl');
 923
 924         my $priority = 10000000;
 925         foreach my $res (@reserves) {
 926             if ($res->{'found'} && $res->{'found'} eq 'W') {
 927                 return ( "Waiting", $res, \@reserves ); # Found it, it is waiting
 928             } elsif ($res->{'found'} && $res->{'found'} eq 'P') {
 929                 return ( "Processing", $res, \@reserves ); # Found determinated hold, e. g. the transferred one
 930             } elsif ($res->{'found'} && $res->{'found'} eq 'T') {
 931                 return ( "Transferred", $res, \@reserves ); # Found determinated hold, e. g. the transferred one
 932             } else {
 933                 my $patron;
 934                 my $item;
 935                 my $local_hold_match;
 936
 937                 if ($LocalHoldsPriority) {
 938                     $patron = Koha::Patrons->find( $res->{borrowernumber} );
 939                     $item = Koha::Items->find($itemnumber);
 940
 941                     unless ($item->exclude_from_local_holds_priority || $patron->category->exclude_from_local_holds_priority) {
 942                         my $local_holds_priority_item_branchcode =
 943                             $item->$LocalHoldsPriorityItemControl;
 944                         my $local_holds_priority_patron_branchcode =
 945                             ( $LocalHoldsPriorityPatronControl eq 'PickupLibrary' )
 946                             ? $res->{branchcode}
 947                             : ( $LocalHoldsPriorityPatronControl eq 'HomeLibrary' )
 948                             ? $patron->branchcode
 949                             : undef;
 950                         $local_hold_match =
 951                             $local_holds_priority_item_branchcode eq
 952                             $local_holds_priority_patron_branchcode;
 953                     }
 954                 }
 955
 956                 # See if this item is more important than what we've got so far
 957                 if ( ( $res->{'priority'} && $res->{'priority'} < $priority ) || $local_hold_match ) {
 958                     $item ||= Koha::Items->find($itemnumber);
 959                     next if $res->{itemtype} && $res->{itemtype} ne $item->effective_itemtype;
 960                     $patron ||= Koha::Patrons->find( $res->{borrowernumber} );
 961                     my $branch = GetReservesControlBranch( $item->unblessed, $patron->unblessed );
 962                     my $branchitemrule = C4::Circulation::GetBranchItemRule($branch,$item->effective_itemtype);
 963                     next if ($branchitemrule->{'holdallowed'} eq 'not_allowed');
 964                     next if (($branchitemrule->{'holdallowed'} eq 'from_home_library') && ($item->homebranch ne $patron->branchcode));
 965                     my $library = Koha::Libraries->find({branchcode=>$item->homebranch});
 966                     next if (($branchitemrule->{'holdallowed'} eq 'from_local_hold_group') && (!$library->validate_hold_sibling({branchcode => $patron->branchcode}) ));
 967                     my $hold_fulfillment_policy = $branchitemrule->{hold_fulfillment_policy};
 968                     next if ( ($hold_fulfillment_policy eq 'holdgroup') && (!$library->validate_hold_sibling({branchcode => $res->{branchcode}})) );
 969                     next if ( ($hold_fulfillment_policy eq 'homebranch') && ($res->{branchcode} ne $item->$hold_fulfillment_policy) );
 970                     next if ( ($hold_fulfillment_policy eq 'holdingbranch') && ($res->{branchcode} ne $item->$hold_fulfillment_policy) );
 971                     next unless $item->can_be_transferred( { to => Koha::Libraries->find( $res->{branchcode} ) } );
 972                     $priority = $res->{'priority'};
 973                     $highest  = $res;
 974                     last if $local_hold_match;
 975                 }
 976             }
 977         }
 978     }
 979
 980     # If we get this far, then no exact match was found.
 981     # We return the most important (i.e. next) reservation.
 982     if ($highest) {
 983         $highest->{'itemnumber'} = $item;
 984         return ( "Reserved", $highest, \@reserves );
 985     }
 986
 987     return ( '' );
 988 }
 989
 990 =head2 CancelExpiredReserves
 991
 992   CancelExpiredReserves();
 993
 994 Cancels all reserves with an expiration date from before today.
 995
 996 =cut
 997
 998 sub CancelExpiredReserves {
 999     my $cancellation_reason = shift;
1000     my $today = dt_from_string();
1001     my $cancel_on_holidays = C4::Context->preference('ExpireReservesOnHolidays');
1002     my $expireWaiting = C4::Context->preference('ExpireReservesMaxPickUpDelay');
1003
1004     my $dtf = Koha::Database->new->schema->storage->datetime_parser;
1005     my $params = {
1006         -or => [
1007             { expirationdate => { '<', $dtf->format_date($today) } },
1008             { patron_expiration_date => { '<' => $dtf->format_date($today) } }
1009         ]
1010     };
1011
1012     $params->{found} = [ { '!=', 'W' }, undef ]  unless $expireWaiting;
1013
1014     # FIXME To move to Koha::Holds->search_expired (?)
1015     my $holds = Koha::Holds->search( $params );
1016
1017     while ( my $hold = $holds->next ) {
1018         my $calendar = Koha::Calendar->new( branchcode => $hold->branchcode );
1019
1020         next if !$cancel_on_holidays && $calendar->is_holiday( $today );
1021
1022         my $cancel_params = {};
1023         $cancel_params->{cancellation_reason} = $cancellation_reason if defined($cancellation_reason);
1024         if ( defined($hold->found) && $hold->found eq 'W' ) {
1025             $cancel_params->{charge_cancel_fee} = 1;
1026         }
1027         $cancel_params->{autofill} = C4::Context->preference('ExpireReservesAutoFill');
1028         $hold->cancel( $cancel_params );
1029     }
1030 }
1031
1032 =head2 AutoUnsuspendReserves
1033
1034   AutoUnsuspendReserves();
1035
1036 Unsuspends all suspended reserves with a suspend_until date from before today.
1037
1038 =cut
1039
1040 sub AutoUnsuspendReserves {
1041     my $today = dt_from_string();
1042
1043     my @holds = Koha::Holds->search( { suspend_until => { '<=' => $today->ymd() } } )->as_list;
1044
1045     map { $_->resume() } @holds;
1046 }
1047
1048 =head2 ModReserve
1049
1050   ModReserve({ rank => $rank,
1051                reserve_id => $reserve_id,
1052                branchcode => $branchcode
1053                [, itemnumber => $itemnumber ]
1054                [, biblionumber => $biblionumber, $borrowernumber => $borrowernumber ]
1055               });
1056
1057 Change a hold request's priority or cancel it.
1058
1059 C<$rank> specifies the effect of the change.  If C<$rank>
1060 is 'n', nothing happens.  This corresponds to leaving a
1061 request alone when changing its priority in the holds queue
1062 for a bib.
1063
1064 If C<$rank> is 'del', the hold request is cancelled.
1065
1066 If C<$rank> is an integer greater than zero, the priority of
1067 the request is set to that value.  Since priority != 0 means
1068 that the item is not waiting on the hold shelf, setting the
1069 priority to a non-zero value also sets the request's found
1070 status and waiting date to NULL.
1071
1072 If the hold is 'found' (waiting, in-transit, processing) the
1073 only field that can be updated is the expiration date.
1074
1075 The optional C<$itemnumber> parameter is used only when
1076 C<$rank> is a non-zero integer; if supplied, the itemnumber
1077 of the hold request is set accordingly; if omitted, the itemnumber
1078 is cleared.
1079
1080 B<FIXME:> Note that the forgoing can have the effect of causing
1081 item-level hold requests to turn into title-level requests.  This
1082 will be fixed once reserves has separate columns for requested
1083 itemnumber and supplying itemnumber.
1084
1085 =cut
1086
1087 sub ModReserve {
1088     my ( $params ) = @_;
1089
1090     my $rank = $params->{'rank'};
1091     my $reserve_id = $params->{'reserve_id'};
1092     my $branchcode = $params->{'branchcode'};
1093     my $itemnumber = $params->{'itemnumber'};
1094     my $suspend_until = $params->{'suspend_until'};
1095     my $borrowernumber = $params->{'borrowernumber'};
1096     my $biblionumber = $params->{'biblionumber'};
1097     my $cancellation_reason = $params->{'cancellation_reason'};
1098     my $date = $params->{expirationdate};
1099
1100     return if defined $rank && $rank eq "n";
1101
1102     return unless ( $reserve_id || ( $borrowernumber && ( $biblionumber || $itemnumber ) ) );
1103
1104     my $hold;
1105     unless ( $reserve_id ) {
1106         my $holds = Koha::Holds->search({ biblionumber => $biblionumber, borrowernumber => $borrowernumber, itemnumber => $itemnumber });
1107         return unless $holds->count; # FIXME Should raise an exception
1108         $hold = $holds->next;
1109         $reserve_id = $hold->reserve_id;
1110     }
1111
1112     $hold ||= Koha::Holds->find($reserve_id);
1113
1114     # FIXME Other calls may fail
1115     Koha::Exceptions::ObjectNotFound->throw( 'No hold with id ' . $reserve_id ) unless $hold;
1116
1117     if ( $rank eq "del" ) {
1118         $hold->cancel({ cancellation_reason => $cancellation_reason });
1119     }
1120     elsif ($hold->found && $hold->priority eq '0' && $date) {
1121         logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
1122             if C4::Context->preference('HoldsLog');
1123
1124         # The only column that can be updated for a found hold is the expiration date
1125         $hold->expirationdate($date)->store();
1126     }
1127     elsif ($rank =~ /^\d+/ and $rank > 0) {
1128         logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
1129             if C4::Context->preference('HoldsLog');
1130
1131         my $properties = {
1132             priority    => $rank,
1133             branchcode  => $branchcode,
1134             itemnumber  => $itemnumber,
1135             found       => undef,
1136             waitingdate => undef
1137         };
1138         if (exists $params->{reservedate}) {
1139             $properties->{reservedate} = $params->{reservedate} || undef;
1140         }
1141         if (exists $params->{expirationdate}) {
1142             $properties->{expirationdate} = $params->{expirationdate} || undef;
1143         }
1144
1145         $hold->set($properties)->store();
1146
1147         if ( defined( $suspend_until ) ) {
1148             if ( $suspend_until ) {
1149                 $hold->suspend_hold( $suspend_until );
1150             } else {
1151                 # If the hold is suspended leave the hold suspended, but convert it to an indefinite hold.
1152                 # If the hold is not suspended, this does nothing.
1153                 $hold->set( { suspend_until => undef } )->store();
1154             }
1155         }
1156
1157         _FixPriority({ reserve_id => $reserve_id, rank =>$rank });
1158     }
1159 }
1160
1161 =head2 ModReserveStatus
1162
1163   &ModReserveStatus($itemnumber, $newstatus);
1164
1165 Update the reserve status for the active (priority=0) reserve.
1166
1167 $itemnumber is the itemnumber the reserve is on
1168
1169 $newstatus is the new status.
1170
1171 =cut
1172
1173 sub ModReserveStatus {
1174
1175     #first : check if we have a reservation for this item .
1176     my ($itemnumber, $newstatus) = @_;
1177     my $dbh = C4::Context->dbh;
1178
1179     my $query = "UPDATE reserves SET found = ?, waitingdate = NOW() WHERE itemnumber = ? AND found IS NULL AND priority = 0";
1180     my $sth_set = $dbh->prepare($query);
1181     $sth_set->execute( $newstatus, $itemnumber );
1182
1183     my $item = Koha::Items->find($itemnumber);
1184     if ( $item->location && $item->location eq 'CART'
1185         && ( !$item->permanent_location || $item->permanent_location ne 'CART' )
1186         && $newstatus ) {
1187       CartToShelf( $itemnumber );
1188     }
1189 }
1190
1191 =head2 ModReserveAffect
1192
1193   &ModReserveAffect($itemnumber,$borrowernumber,$diffBranchSend,$reserve_id, $desk_id, $notify_library);
1194
1195 This function affect an item and a status for a given reserve, either fetched directly
1196 by record_id, or by borrowernumber and itemnumber or biblionumber. If only biblionumber
1197 is given, only first reserve returned is affected, which is ok for anything but
1198 multi-item holds.
1199
1200 if $transferToDo is not set, then the status is set to "Waiting" as well.
1201 otherwise, a transfer is on the way, and the end of the transfer will
1202 take care of the waiting status
1203
1204 This function also removes any entry of the hold in holds queue table.
1205
1206 =cut
1207
1208 sub ModReserveAffect {
1209     my ( $itemnumber, $borrowernumber, $transferToDo, $reserve_id, $desk_id, $notify_library ) = @_;
1210     my $dbh = C4::Context->dbh;
1211
1212     # we want to attach $itemnumber to $borrowernumber, find the biblionumber
1213     # attached to $itemnumber
1214     my $sth = $dbh->prepare("SELECT biblionumber FROM items WHERE itemnumber=?");
1215     $sth->execute($itemnumber);
1216     my ($biblionumber) = $sth->fetchrow;
1217
1218     # get request - need to find out if item is already
1219     # waiting in order to not send duplicate hold filled notifications
1220
1221     my $hold;
1222     # Find hold by id if we have it
1223     $hold = Koha::Holds->find( $reserve_id ) if $reserve_id;
1224     # Find item level hold for this item if there is one
1225     $hold ||= Koha::Holds->search( { borrowernumber => $borrowernumber, itemnumber => $itemnumber } )->next();
1226     # Find record level hold if there is no item level hold
1227     $hold ||= Koha::Holds->search( { borrowernumber => $borrowernumber, biblionumber => $biblionumber } )->next();
1228
1229     return unless $hold;
1230
1231     my $already_on_shelf = $hold->found && $hold->found eq 'W';
1232
1233     $hold->itemnumber($itemnumber);
1234
1235     if ($transferToDo) {
1236         $hold->set_transfer();
1237     } elsif (C4::Context->preference('HoldsNeedProcessingSIP')
1238              && C4::Context->interface eq 'sip'
1239              && !$already_on_shelf) {
1240         $hold->set_processing();
1241     } else {
1242         $hold->set_waiting($desk_id);
1243         _koha_notify_reserve( $hold->reserve_id ) unless $already_on_shelf;
1244         # Complete transfer if one exists
1245         my $transfer = $hold->item->get_transfer;
1246         $transfer->receive if $transfer;
1247     }
1248
1249     _koha_notify_hold_changed( $hold ) if $notify_library;
1250
1251     _FixPriority( { biblionumber => $biblionumber } );
1252     my $item = Koha::Items->find($itemnumber);
1253     if ( $item->location && $item->location eq 'CART'
1254         && ( !$item->permanent_location || $item->permanent_location ne 'CART' ) ) {
1255       CartToShelf( $itemnumber );
1256     }
1257
1258     my $std = $dbh->prepare(q{
1259         DELETE  q, t
1260         FROM    tmp_holdsqueue q
1261         INNER JOIN hold_fill_targets t
1262         ON  q.borrowernumber = t.borrowernumber
1263             AND q.biblionumber = t.biblionumber
1264             AND q.itemnumber = t.itemnumber
1265             AND q.item_level_request = t.item_level_request
1266             AND q.holdingbranch = t.source_branchcode
1267         WHERE t.reserve_id = ?
1268     });
1269     $std->execute($hold->reserve_id);
1270
1271     logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, $hold )
1272         if C4::Context->preference('HoldsLog');
1273
1274     return;
1275 }
1276
1277 =head2 ModReserveCancelAll
1278
1279   ($messages,$nextreservinfo) = &ModReserveCancelAll($itemnumber,$borrowernumber,$reason);
1280
1281 function to cancel reserv,check other reserves, and transfer document if it's necessary
1282
1283 =cut
1284
1285 sub ModReserveCancelAll {
1286     my $messages;
1287     my $nextreservinfo;
1288     my ( $itemnumber, $borrowernumber, $cancellation_reason ) = @_;
1289
1290     #step 1 : cancel the reservation
1291     my $holds = Koha::Holds->search({ itemnumber => $itemnumber, borrowernumber => $borrowernumber });
1292     return unless $holds->count;
1293     $holds->next->cancel({ cancellation_reason => $cancellation_reason });
1294
1295     #step 2 launch the subroutine of the others reserves
1296     ( $messages, $nextreservinfo ) = GetOtherReserves($itemnumber);
1297
1298     return ( $messages, $nextreservinfo->{borrowernumber} );
1299 }
1300
1301 =head2 ModReserveMinusPriority
1302
1303   &ModReserveMinusPriority($itemnumber,$borrowernumber,$biblionumber)
1304
1305 Reduce the values of queued list
1306
1307 =cut
1308
1309 sub ModReserveMinusPriority {
1310     my ( $itemnumber, $reserve_id ) = @_;
1311
1312     #first step update the value of the first person on reserv
1313     my $dbh   = C4::Context->dbh;
1314     my $query = "
1315         UPDATE reserves
1316         SET    priority = 0 , itemnumber = ?
1317         WHERE  reserve_id = ?
1318     ";
1319     my $sth_upd = $dbh->prepare($query);
1320     $sth_upd->execute( $itemnumber, $reserve_id );
1321     # second step update all others reserves
1322     _FixPriority({ reserve_id => $reserve_id, rank => '0' });
1323 }
1324
1325 =head2 IsAvailableForItemLevelRequest
1326
1327   my $is_available = IsAvailableForItemLevelRequest( $item_record, $borrower_record, $pickup_branchcode );
1328
1329 Checks whether a given item record is available for an
1330 item-level hold request.  An item is available if
1331
1332 * it is not lost AND
1333 * it is not damaged AND
1334 * it is not withdrawn AND
1335 * a waiting or in transit reserve is placed on
1336 * does not have a not for loan value > 0
1337
1338 Need to check the issuingrules onshelfholds column,
1339 if this is set items on the shelf can be placed on hold
1340
1341 Note that IsAvailableForItemLevelRequest() does not
1342 check if the staff operator is authorized to place
1343 a request on the item - in particular,
1344 this routine does not check IndependentBranches
1345 and canreservefromotherbranches.
1346
1347 Note also that this subroutine does not checks smart
1348 rules limits for item by reservesallowed/holds_per_record
1349 values, this complemented in calling code with calls and
1350 checks with CanItemBeReserved or CanBookBeReserved.
1351
1352 =cut
1353
1354 sub IsAvailableForItemLevelRequest {
1355     my $item                = shift;
1356     my $patron              = shift;
1357     my $pickup_branchcode   = shift;
1358     # items_any_available is precalculated status passed from request.pl when set of items
1359     # looped outside of IsAvailableForItemLevelRequest to avoid nested loops:
1360     my $items_any_available = shift;
1361
1362     my $dbh = C4::Context->dbh;
1363     # must check the notforloan setting of the itemtype
1364     # FIXME - a lot of places in the code do this
1365     #         or something similar - need to be
1366     #         consolidated
1367     my $itemtype = $item->effective_itemtype;
1368     return 0
1369       unless defined $itemtype;
1370     my $notforloan_per_itemtype = Koha::ItemTypes->find($itemtype)->notforloan;
1371
1372     return 0 if
1373         $notforloan_per_itemtype ||
1374         $item->itemlost        ||
1375         $item->notforloan > 0  || # item with negative or zero notforloan value is holdable
1376         $item->withdrawn        ||
1377         ($item->damaged && !C4::Context->preference('AllowHoldsOnDamagedItems'));
1378
1379     if ($pickup_branchcode) {
1380         my $destination = Koha::Libraries->find($pickup_branchcode);
1381         return 0 unless $destination;
1382         return 0 unless $destination->pickup_location;
1383         return 0 unless $item->can_be_transferred( { to => $destination } );
1384         my $reserves_control_branch =
1385             GetReservesControlBranch( $item->unblessed(), $patron->unblessed() );
1386         my $branchitemrule =
1387             C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->itype );
1388         my $home_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
1389         return 0 unless $branchitemrule->{hold_fulfillment_policy} ne 'holdgroup' || $home_library->validate_hold_sibling( {branchcode => $pickup_branchcode} );
1390     }
1391
1392     my $on_shelf_holds = Koha::CirculationRules->get_onshelfholds_policy( { item => $item, patron => $patron } );
1393
1394     if ( $on_shelf_holds == 1 ) {
1395         return 1;
1396     } elsif ( $on_shelf_holds == 2 ) {
1397
1398         # if we have this param predefined from outer caller sub, we just need
1399         # to return it, so we saving from having loop inside other loop:
1400         return  $items_any_available ? 0 : 1
1401             if defined $items_any_available;
1402
1403         my $any_available = ItemsAnyAvailableAndNotRestricted( { biblionumber => $item->biblionumber, patron => $patron });
1404         return $any_available ? 0 : 1;
1405     } else { # on_shelf_holds == 0 "If any unavailable" (the description is rather cryptic and could still be improved)
1406         return $item->onloan || IsItemOnHoldAndFound( $item->itemnumber );
1407     }
1408 }
1409
1410 =head2 ItemsAnyAvailableAndNotRestricted
1411
1412   ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron });
1413
1414 This function checks all items for specified biblionumber (numeric) against patron (object)
1415 and returns true (1) if at least one item available for loan/check out/present/not held
1416 and also checks other parameters logic which not restricts item for hold at all (for ex.
1417 AllowHoldsOnDamagedItems or 'holdallowed' own/sibling library)
1418
1419 =cut
1420
1421 sub ItemsAnyAvailableAndNotRestricted {
1422     my $param = shift;
1423
1424     my @items = Koha::Items->search( { biblionumber => $param->{biblionumber} } )->as_list;
1425
1426     foreach my $i (@items) {
1427         my $reserves_control_branch =
1428             GetReservesControlBranch( $i->unblessed(), $param->{patron}->unblessed );
1429         my $branchitemrule =
1430             C4::Circulation::GetBranchItemRule( $reserves_control_branch, $i->itype );
1431         my $item_library = Koha::Libraries->find( { branchcode => $i->homebranch } );
1432
1433         # we can return (end the loop) when first one found:
1434         return 1
1435             unless $i->itemlost
1436             || $i->notforloan # items with non-zero notforloan cannot be checked out
1437             || $i->withdrawn
1438             || $i->onloan
1439             || IsItemOnHoldAndFound( $i->id )
1440             || ( $i->damaged
1441                  && ! C4::Context->preference('AllowHoldsOnDamagedItems') )
1442             || Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
1443             || $branchitemrule->{holdallowed} eq 'from_home_library' && $param->{patron}->branchcode ne $i->homebranch
1444             || $branchitemrule->{holdallowed} eq 'from_local_hold_group' && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } )
1445             || CanItemBeReserved( $param->{patron}, $i )->{status} ne 'OK';
1446     }
1447
1448     return 0;
1449 }
1450
1451 =head2 AlterPriority
1452
1453   AlterPriority( $where, $reserve_id, $prev_priority, $next_priority, $first_priority, $last_priority );
1454
1455 This function changes a reserve's priority up, down, to the top, or to the bottom.
1456 Input: $where is 'up', 'down', 'top' or 'bottom'. Biblionumber, Date reserve was placed
1457
1458 =cut
1459
1460 sub AlterPriority {
1461     my ( $where, $reserve_id, $prev_priority, $next_priority, $first_priority, $last_priority ) = @_;
1462
1463     my $hold = Koha::Holds->find( $reserve_id );
1464     return unless $hold;
1465
1466     if ( $hold->cancellationdate ) {
1467         warn "I cannot alter the priority for reserve_id $reserve_id, the reserve has been cancelled (" . $hold->cancellationdate . ')';
1468         return;
1469     }
1470
1471     if ( $where eq 'up' ) {
1472       return unless $prev_priority;
1473       _FixPriority({ reserve_id => $reserve_id, rank => $prev_priority })
1474     } elsif ( $where eq 'down' ) {
1475       return unless $next_priority;
1476       _FixPriority({ reserve_id => $reserve_id, rank => $next_priority })
1477     } elsif ( $where eq 'top' ) {
1478       _FixPriority({ reserve_id => $reserve_id, rank => $first_priority })
1479     } elsif ( $where eq 'bottom' ) {
1480       _FixPriority({ reserve_id => $reserve_id, rank => $last_priority });
1481     }
1482
1483     Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
1484         {
1485             biblio_ids => [ $hold->biblionumber ]
1486         }
1487     ) if C4::Context->preference('RealTimeHoldsQueue');
1488     # FIXME Should return the new priority
1489 }
1490
1491 =head2 ToggleLowestPriority
1492
1493   ToggleLowestPriority( $borrowernumber, $biblionumber );
1494
1495 This function sets the lowestPriority field to true if is false, and false if it is true.
1496
1497 =cut
1498
1499 sub ToggleLowestPriority {
1500     my ( $reserve_id ) = @_;
1501
1502     my $dbh = C4::Context->dbh;
1503
1504     my $sth = $dbh->prepare( "UPDATE reserves SET lowestPriority = NOT lowestPriority WHERE reserve_id = ?");
1505     $sth->execute( $reserve_id );
1506
1507     _FixPriority({ reserve_id => $reserve_id, rank => '999999' });
1508 }
1509
1510 =head2 ToggleSuspend
1511
1512   ToggleSuspend( $reserve_id );
1513
1514 This function sets the suspend field to true if is false, and false if it is true.
1515 If the reserve is currently suspended with a suspend_until date, that date will
1516 be cleared when it is unsuspended.
1517
1518 =cut
1519
1520 sub ToggleSuspend {
1521     my ( $reserve_id, $suspend_until ) = @_;
1522
1523     my $hold = Koha::Holds->find( $reserve_id );
1524
1525     if ( $hold->is_suspended ) {
1526         $hold->resume()
1527     } else {
1528         $hold->suspend_hold( $suspend_until );
1529     }
1530 }
1531
1532 =head2 SuspendAll
1533
1534   SuspendAll(
1535       borrowernumber   => $borrowernumber,
1536       [ biblionumber   => $biblionumber, ]
1537       [ suspend_until  => $suspend_until, ]
1538       [ suspend        => $suspend ]
1539   );
1540
1541   This function accepts a set of hash keys as its parameters.
1542   It requires either borrowernumber or biblionumber, or both.
1543
1544   suspend_until is wholly optional.
1545
1546 =cut
1547
1548 sub SuspendAll {
1549     my %params = @_;
1550
1551     my $borrowernumber = $params{'borrowernumber'} || undef;
1552     my $biblionumber   = $params{'biblionumber'}   || undef;
1553     my $suspend_until  = $params{'suspend_until'}  || undef;
1554     my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;
1555
1556     return unless ( $borrowernumber || $biblionumber );
1557
1558     my $params;
1559     $params->{found}          = undef;
1560     $params->{borrowernumber} = $borrowernumber if $borrowernumber;
1561     $params->{biblionumber}   = $biblionumber if $biblionumber;
1562
1563     my @holds = Koha::Holds->search($params)->as_list;
1564
1565     if ($suspend) {
1566         map { $_->suspend_hold($suspend_until) } @holds;
1567     }
1568     else {
1569         map { $_->resume() } @holds;
1570     }
1571 }
1572
1573
1574 =head2 _FixPriority
1575
1576   _FixPriority({
1577     reserve_id => $reserve_id,
1578     [rank => $rank,]
1579     [ignoreSetLowestRank => $ignoreSetLowestRank]
1580   });
1581
1582   or
1583
1584   _FixPriority({ biblionumber => $biblionumber});
1585
1586 This routine adjusts the priority of a hold request and holds
1587 on the same bib.
1588
1589 In the first form, where a reserve_id is passed, the priority of the
1590 hold is set to supplied rank, and other holds for that bib are adjusted
1591 accordingly.  If the rank is "del", the hold is cancelled.  If no rank
1592 is supplied, all of the holds on that bib have their priority adjusted
1593 as if the second form had been used.
1594
1595 In the second form, where a biblionumber is passed, the holds on that
1596 bib (that are not captured) are sorted in order of increasing priority,
1597 then have reserves.priority set so that the first non-captured hold
1598 has its priority set to 1, the second non-captured hold has its priority
1599 set to 2, and so forth.
1600
1601 In both cases, holds that have the lowestPriority flag on are have their
1602 priority adjusted to ensure that they remain at the end of the line.
1603
1604 Note that the ignoreSetLowestRank parameter is meant to be used only
1605 when _FixPriority calls itself.
1606
1607 =cut
1608
1609 sub _FixPriority {
1610     my ( $params ) = @_;
1611     my $reserve_id = $params->{reserve_id};
1612     my $rank = $params->{rank} // '';
1613     my $ignoreSetLowestRank = $params->{ignoreSetLowestRank};
1614     my $biblionumber = $params->{biblionumber};
1615
1616     my $dbh = C4::Context->dbh;
1617
1618     my $hold;
1619     if ( $reserve_id ) {
1620         $hold = Koha::Holds->find( $reserve_id );
1621         if (!defined $hold){
1622             # may have already been checked out and hold fulfilled
1623             $hold = Koha::Old::Holds->find( $reserve_id );
1624         }
1625         return unless $hold;
1626     }
1627
1628     unless ( $biblionumber ) { # FIXME This is a very weird API
1629         $biblionumber = $hold->biblionumber;
1630     }
1631
1632     if ( $rank eq "del" ) { # FIXME will crash if called without $hold
1633         $hold->cancel;
1634     }
1635     elsif ( $reserve_id && ( $rank eq "W" || $rank eq "0" ) ) {
1636
1637         # make sure priority for waiting or in-transit items is 0
1638         my $query = "
1639             UPDATE reserves
1640             SET    priority = 0
1641             WHERE reserve_id = ?
1642             AND found IN ('W', 'T', 'P')
1643         ";
1644         my $sth = $dbh->prepare($query);
1645         $sth->execute( $reserve_id );
1646     }
1647     my @priority;
1648
1649     # get whats left
1650     my $query = "
1651         SELECT reserve_id, borrowernumber, reservedate
1652         FROM   reserves
1653         WHERE  biblionumber   = ?
1654           AND  ((found <> 'W' AND found <> 'T' AND found <> 'P') OR found IS NULL)
1655         ORDER BY priority ASC
1656     ";
1657     my $sth = $dbh->prepare($query);
1658     $sth->execute( $biblionumber );
1659     while ( my $line = $sth->fetchrow_hashref ) {
1660         push( @priority,     $line );
1661     }
1662
1663     # FIXME This whole sub must be rewritten, especially to highlight what is done when reserve_id is not given
1664     # To find the matching index
1665     my $i;
1666     my $key = -1;    # to allow for 0 to be a valid result
1667     for ( $i = 0 ; $i < @priority ; $i++ ) {
1668         if ( $reserve_id && $reserve_id == $priority[$i]->{'reserve_id'} ) {
1669             $key = $i;    # save the index
1670             last;
1671         }
1672     }
1673
1674     # if index exists in array then move it to new position
1675     if ( $key > -1 && $rank ne 'del' && $rank > 0 ) {
1676         my $new_rank = $rank - 1; # $new_rank is what you want the new index to be in the array
1677         my $moving_item = splice( @priority, $key, 1 );
1678         $new_rank = scalar @priority if $new_rank > scalar @priority;
1679         splice( @priority, $new_rank, 0, $moving_item );
1680     }
1681
1682     # now fix the priority on those that are left....
1683     $query = "
1684         UPDATE reserves
1685         SET    priority = ?
1686         WHERE  reserve_id = ?
1687     ";
1688     $sth = $dbh->prepare($query);
1689     for ( my $j = 0 ; $j < @priority ; $j++ ) {
1690         $sth->execute(
1691             $j + 1,
1692             $priority[$j]->{'reserve_id'}
1693         );
1694     }
1695
1696     unless ( $ignoreSetLowestRank ) {
1697         $sth = $dbh->prepare( "SELECT reserve_id FROM reserves WHERE lowestPriority = 1 AND biblionumber = ? ORDER BY priority" );
1698         $sth->execute($biblionumber);
1699       while ( my $res = $sth->fetchrow_hashref() ) {
1700         _FixPriority({
1701             reserve_id => $res->{'reserve_id'},
1702             rank => '999999',
1703             ignoreSetLowestRank => 1
1704         });
1705       }
1706     }
1707 }
1708
1709 =head2 _Findgroupreserve
1710
1711   @results = &_Findgroupreserve($biblioitemnumber, $biblionumber, $itemnumber, $lookahead, $ignore_borrowers);
1712
1713 Looks for a holds-queue based item-specific match first, then for a holds-queue title-level match, returning the
1714 first match found.  If neither, then we look for non-holds-queue based holds.
1715 Lookahead is the number of days to look in advance.
1716
1717 C<&_Findgroupreserve> returns :
1718 C<@results> is an array of references-to-hash whose keys are mostly
1719 fields from the reserves table of the Koha database, plus
1720 C<biblioitemnumber>.
1721
1722 This routine with either return:
1723 1 - Item specific holds from the holds queue
1724 2 - Title level holds from the holds queue
1725 3 - All holds for this biblionumber
1726
1727 All return values will respect any borrowernumbers passed as arrayref in $ignore_borrowers
1728
1729 =cut
1730
1731 sub _Findgroupreserve {
1732     my ( $bibitem, $biblio, $itemnumber, $lookahead, $ignore_borrowers) = @_;
1733     my $dbh   = C4::Context->dbh;
1734
1735     # TODO: consolidate at least the SELECT portion of the first 2 queries to a common $select var.
1736     # check for exact targeted match
1737     my $item_level_target_query = qq{
1738         SELECT reserves.biblionumber        AS biblionumber,
1739                reserves.borrowernumber      AS borrowernumber,
1740                reserves.reservedate         AS reservedate,
1741                reserves.branchcode          AS branchcode,
1742                reserves.cancellationdate    AS cancellationdate,
1743                reserves.found               AS found,
1744                reserves.reservenotes        AS reservenotes,
1745                reserves.priority            AS priority,
1746                reserves.timestamp           AS timestamp,
1747                biblioitems.biblioitemnumber AS biblioitemnumber,
1748                reserves.itemnumber          AS itemnumber,
1749                reserves.reserve_id          AS reserve_id,
1750                reserves.itemtype            AS itemtype,
1751                reserves.non_priority        AS non_priority
1752         FROM reserves
1753         JOIN biblioitems USING (biblionumber)
1754         JOIN hold_fill_targets USING (reserve_id)
1755         WHERE found IS NULL
1756         AND priority > 0
1757         AND item_level_request = 1
1758         AND hold_fill_targets.itemnumber = ?
1759         AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1760         AND suspend = 0
1761         ORDER BY priority
1762     };
1763     my $sth = $dbh->prepare($item_level_target_query);
1764     $sth->execute($itemnumber, $lookahead||0);
1765     my @results;
1766     if ( my $data = $sth->fetchrow_hashref ) {
1767         push( @results, $data )
1768           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1769     }
1770     return @results if @results;
1771
1772     # check for title-level targeted match
1773     my $title_level_target_query = qq{
1774         SELECT reserves.biblionumber        AS biblionumber,
1775                reserves.borrowernumber      AS borrowernumber,
1776                reserves.reservedate         AS reservedate,
1777                reserves.branchcode          AS branchcode,
1778                reserves.cancellationdate    AS cancellationdate,
1779                reserves.found               AS found,
1780                reserves.reservenotes        AS reservenotes,
1781                reserves.priority            AS priority,
1782                reserves.timestamp           AS timestamp,
1783                biblioitems.biblioitemnumber AS biblioitemnumber,
1784                reserves.itemnumber          AS itemnumber,
1785                reserves.reserve_id          AS reserve_id,
1786                reserves.itemtype            AS itemtype,
1787                reserves.non_priority        AS non_priority
1788         FROM reserves
1789         JOIN biblioitems USING (biblionumber)
1790         JOIN hold_fill_targets USING (reserve_id)
1791         WHERE found IS NULL
1792         AND priority > 0
1793         AND item_level_request = 0
1794         AND hold_fill_targets.itemnumber = ?
1795         AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1796         AND suspend = 0
1797         ORDER BY priority
1798     };
1799     $sth = $dbh->prepare($title_level_target_query);
1800     $sth->execute($itemnumber, $lookahead||0);
1801     @results = ();
1802     if ( my $data = $sth->fetchrow_hashref ) {
1803         push( @results, $data )
1804           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1805     }
1806     return @results if @results;
1807
1808     my $query = qq{
1809         SELECT reserves.biblionumber               AS biblionumber,
1810                reserves.borrowernumber             AS borrowernumber,
1811                reserves.reservedate                AS reservedate,
1812                reserves.waitingdate                AS waitingdate,
1813                reserves.branchcode                 AS branchcode,
1814                reserves.cancellationdate           AS cancellationdate,
1815                reserves.found                      AS found,
1816                reserves.reservenotes               AS reservenotes,
1817                reserves.priority                   AS priority,
1818                reserves.timestamp                  AS timestamp,
1819                reserves.itemnumber                 AS itemnumber,
1820                reserves.reserve_id                 AS reserve_id,
1821                reserves.itemtype                   AS itemtype,
1822                reserves.non_priority        AS non_priority
1823         FROM reserves
1824         WHERE reserves.biblionumber = ?
1825           AND (reserves.itemnumber IS NULL OR reserves.itemnumber = ?)
1826           AND reserves.reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1827           AND suspend = 0
1828           ORDER BY priority
1829     };
1830     $sth = $dbh->prepare($query);
1831     $sth->execute( $biblio, $itemnumber, $lookahead||0);
1832     @results = ();
1833     while ( my $data = $sth->fetchrow_hashref ) {
1834         push( @results, $data )
1835           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1836     }
1837     return @results;
1838 }
1839
1840 =head2 _koha_notify_reserve
1841
1842   _koha_notify_reserve( $hold->reserve_id );
1843
1844 Sends a notification to the patron that their hold has been filled (through
1845 ModReserveAffect)
1846
1847 The letter code for this notice may be found using the following query:
1848
1849     select distinct letter_code
1850     from message_transports
1851     inner join message_attributes using (message_attribute_id)
1852     where message_name = 'Hold_Filled'
1853
1854 This will probably sipmly be 'HOLD', but because it is defined in the database,
1855 it is subject to addition or change.
1856
1857 The following tables are availalbe witin the notice:
1858
1859     branches
1860     borrowers
1861     biblio
1862     biblioitems
1863     reserves
1864     items
1865
1866 =cut
1867
1868 sub _koha_notify_reserve {
1869     my $reserve_id = shift;
1870
1871     my $hold = Koha::Holds->find($reserve_id);
1872     my $borrowernumber = $hold->borrowernumber;
1873
1874     my $patron = Koha::Patrons->find( $borrowernumber );
1875
1876     # Try to get the borrower's email address
1877     my $to_address = $patron->notice_email_address;
1878
1879     my $messagingprefs = C4::Members::Messaging::GetMessagingPreferences( {
1880             borrowernumber => $borrowernumber,
1881             message_name => 'Hold_Filled'
1882     } );
1883
1884     my $library = Koha::Libraries->find( $hold->branchcode );
1885     my $inbound_email_address = $library->inbound_email_address;
1886
1887     my %letter_params = (
1888         module => 'reserves',
1889         branchcode => $hold->branchcode,
1890         lang => $patron->lang,
1891         tables => {
1892             'branches'       => $library->unblessed,
1893             'borrowers'      => $patron->unblessed,
1894             'biblio'         => $hold->biblionumber,
1895             'biblioitems'    => $hold->biblionumber,
1896             'reserves'       => $hold->unblessed,
1897             'items'          => $hold->itemnumber,
1898         },
1899     );
1900
1901     my $notification_sent = 0; #Keeping track if a Hold_filled message is sent. If no message can be sent, then default to a print message.
1902     my $send_notification = sub {
1903         my ( $mtt, $letter_code ) = (@_);
1904         return unless defined $letter_code;
1905         $letter_params{letter_code} = $letter_code;
1906         $letter_params{message_transport_type} = $mtt;
1907         my $letter =  C4::Letters::GetPreparedLetter ( %letter_params );
1908         unless ($letter) {
1909             warn "Could not find a letter called '$letter_params{'letter_code'}' for $mtt in the 'reserves' module";
1910             return;
1911         }
1912
1913         C4::Letters::EnqueueLetter( {
1914             letter => $letter,
1915             borrowernumber => $borrowernumber,
1916             from_address => $inbound_email_address,
1917             message_transport_type => $mtt,
1918         } );
1919     };
1920
1921     while ( my ( $mtt, $letter_code ) = each %{ $messagingprefs->{transports} } ) {
1922         next if (
1923                ( $mtt eq 'email' and not $to_address ) # No email address
1924             or ( $mtt eq 'sms'   and not $patron->smsalertnumber ) # No SMS number
1925             or ( $mtt eq 'itiva' and C4::Context->preference('TalkingTechItivaPhoneNotification') ) # Notice is handled by TalkingTech_itiva_outbound.pl
1926             or ( $mtt eq 'phone' and not $patron->phone ) # No phone number to call
1927         );
1928
1929         &$send_notification($mtt, $letter_code);
1930         $notification_sent++;
1931     }
1932     #Making sure that a print notification is sent if no other transport types can be utilized.
1933     if (! $notification_sent) {
1934         &$send_notification('print', 'HOLD');
1935     }
1936
1937 }
1938
1939 =head2 _koha_notify_hold_changed
1940
1941   _koha_notify_hold_changed( $hold_object );
1942
1943 =cut
1944
1945 sub _koha_notify_hold_changed {
1946     my $hold = shift;
1947
1948     my $patron = $hold->patron;
1949     my $library = $hold->branch;
1950
1951     my $letter = C4::Letters::GetPreparedLetter(
1952         module      => 'reserves',
1953         letter_code => 'HOLD_CHANGED',
1954         branchcode  => $hold->branchcode,
1955         substitute  => { today => output_pref( dt_from_string ) },
1956         tables      => {
1957             'branches'    => $library->unblessed,
1958             'borrowers'   => $patron->unblessed,
1959             'biblio'      => $hold->biblionumber,
1960             'biblioitems' => $hold->biblionumber,
1961             'reserves'    => $hold->unblessed,
1962             'items'       => $hold->itemnumber,
1963         },
1964     );
1965
1966     return unless $letter;
1967
1968     my $email =
1969          C4::Context->preference('ExpireReservesAutoFillEmail')
1970       || $library->inbound_email_address;
1971
1972     C4::Letters::EnqueueLetter(
1973         {
1974             letter                 => $letter,
1975             borrowernumber         => $patron->id,
1976             message_transport_type => 'email',
1977             from_address           => $email,
1978             to_address             => $email,
1979         }
1980     );
1981 }
1982
1983 =head2 _ShiftPriority
1984
1985   $new_priority = _ShiftPriority( $biblionumber, $priority );
1986
1987 This increments the priority of all reserves after the one
1988 with either the lowest date after C<$reservedate>
1989 or the lowest priority after C<$priority>.
1990
1991 It effectively makes room for a new reserve to be inserted with a certain
1992 priority, which is returned.
1993
1994 This is most useful when the reservedate can be set by the user.  It allows
1995 the new reserve to be placed before other reserves that have a later
1996 reservedate.  Since priority also is set by the form in reserves/request.pl
1997 the sub accounts for that too.
1998
1999 =cut
2000
2001 sub _ShiftPriority {
2002     my ( $biblio, $new_priority ) = @_;
2003
2004     my $dbh = C4::Context->dbh;
2005     my $query = "SELECT priority FROM reserves WHERE biblionumber = ? AND priority > ? ORDER BY priority ASC LIMIT 1";
2006     my $sth = $dbh->prepare( $query );
2007     $sth->execute( $biblio, $new_priority );
2008     my $min_priority = $sth->fetchrow;
2009     # if no such matches are found, $new_priority remains as original value
2010     $new_priority = $min_priority if ( $min_priority );
2011
2012     # Shift the priority up by one; works in conjunction with the next SQL statement
2013     $query = "UPDATE reserves
2014               SET priority = priority+1
2015               WHERE biblionumber = ?
2016               AND borrowernumber = ?
2017               AND reservedate = ?
2018               AND found IS NULL";
2019     my $sth_update = $dbh->prepare( $query );
2020
2021     # Select all reserves for the biblio with priority greater than $new_priority, and order greatest to least
2022     $query = "SELECT borrowernumber, reservedate FROM reserves WHERE priority >= ? AND biblionumber = ? ORDER BY priority DESC";
2023     $sth = $dbh->prepare( $query );
2024     $sth->execute( $new_priority, $biblio );
2025     while ( my $row = $sth->fetchrow_hashref ) {
2026         $sth_update->execute( $biblio, $row->{borrowernumber}, $row->{reservedate} );
2027     }
2028
2029     return $new_priority;  # so the caller knows what priority they wind up receiving
2030 }
2031
2032 =head2 MoveReserve
2033
2034   MoveReserve( $itemnumber, $borrowernumber, $cancelreserve )
2035
2036 Use when checking out an item to handle reserves
2037 If $cancelreserve boolean is set to true, it will remove existing reserve
2038
2039 =cut
2040
2041 sub MoveReserve {
2042     my ( $itemnumber, $borrowernumber, $cancelreserve ) = @_;
2043
2044     $cancelreserve //= 0;
2045
2046     my $lookahead = C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
2047     my ( $restype, $res, undef ) = CheckReserves( $itemnumber, undef, $lookahead );
2048     return unless $res;
2049
2050     my $biblionumber = $res->{biblionumber};
2051
2052     if ($res->{borrowernumber} == $borrowernumber) {
2053         my $hold = Koha::Holds->find( $res->{reserve_id} );
2054         $hold->fill;
2055     }
2056     else {
2057         # warn "Reserved";
2058         # The item is reserved by someone else.
2059         # Find this item in the reserves
2060
2061         my $borr_res  = Koha::Holds->search({
2062             borrowernumber => $borrowernumber,
2063             biblionumber   => $biblionumber,
2064         },{
2065             order_by       => 'priority'
2066         })->next();
2067
2068         if ( $borr_res ) {
2069             # The item is reserved by the current patron
2070             $borr_res->fill;
2071         }
2072
2073         if ( $cancelreserve eq 'revert' ) { ## Revert waiting reserve to priority 1
2074             RevertWaitingStatus({ itemnumber => $itemnumber });
2075         }
2076         elsif ( $cancelreserve eq 'cancel' || $cancelreserve ) { # cancel reserves on this item
2077             my $hold = Koha::Holds->find( $res->{reserve_id} );
2078             $hold->cancel;
2079         }
2080     }
2081 }
2082
2083 =head2 MergeHolds
2084
2085   MergeHolds($dbh,$to_biblio, $from_biblio);
2086
2087 This shifts the holds from C<$from_biblio> to C<$to_biblio> and reorders them by the date they were placed
2088
2089 =cut
2090
2091 sub MergeHolds {
2092     my ( $dbh, $to_biblio, $from_biblio ) = @_;
2093     my $sth = $dbh->prepare(
2094         "SELECT count(*) as reserve_count FROM reserves WHERE biblionumber = ?"
2095     );
2096     $sth->execute($from_biblio);
2097     if ( my $data = $sth->fetchrow_hashref() ) {
2098
2099         # holds exist on old record, if not we don't need to do anything
2100         $sth = $dbh->prepare(
2101             "UPDATE reserves SET biblionumber = ? WHERE biblionumber = ?");
2102         $sth->execute( $to_biblio, $from_biblio );
2103
2104         # Reorder by date
2105         # don't reorder those already waiting
2106
2107         $sth = $dbh->prepare(
2108 "SELECT * FROM reserves WHERE biblionumber = ? AND (found NOT IN ('W', 'T', 'P') OR found is NULL) ORDER BY reservedate ASC"
2109         );
2110         my $upd_sth = $dbh->prepare(
2111 "UPDATE reserves SET priority = ? WHERE biblionumber = ? AND borrowernumber = ?
2112         AND reservedate = ? AND (itemnumber = ? or itemnumber is NULL) "
2113         );
2114         $sth->execute( $to_biblio );
2115         my $priority = 1;
2116         while ( my $reserve = $sth->fetchrow_hashref() ) {
2117             $upd_sth->execute(
2118                 $priority,                    $to_biblio,
2119                 $reserve->{'borrowernumber'}, $reserve->{'reservedate'},
2120                 $reserve->{'itemnumber'}
2121             );
2122             $priority++;
2123         }
2124     }
2125 }
2126
2127 =head2 RevertWaitingStatus
2128
2129   RevertWaitingStatus({ itemnumber => $itemnumber });
2130
2131   Reverts a 'waiting' hold back to a regular hold with a priority of 1.
2132
2133   Caveat: Any waiting hold fixed with RevertWaitingStatus will be an
2134           item level hold, even if it was only a bibliolevel hold to
2135           begin with. This is because we can no longer know if a hold
2136           was item-level or bib-level after a hold has been set to
2137           waiting status.
2138
2139 =cut
2140
2141 sub RevertWaitingStatus {
2142     my ( $params ) = @_;
2143     my $itemnumber = $params->{'itemnumber'};
2144
2145     return unless ( $itemnumber );
2146
2147     my $dbh = C4::Context->dbh;
2148
2149     ## Get the waiting reserve we want to revert
2150     my $hold = Koha::Holds->search(
2151         {
2152             itemnumber => $itemnumber,
2153             found => { not => undef },
2154         }
2155     )->next;
2156
2157     ## Increment the priority of all other non-waiting
2158     ## reserves for this bib record
2159     my $holds = Koha::Holds->search({ biblionumber => $hold->biblionumber, priority => { '>' => 0 } })
2160                            ->update({ priority => \'priority + 1' }, { no_triggers => 1 });
2161
2162     ## Fix up the currently waiting reserve
2163     $hold->set(
2164         {
2165             priority    => 1,
2166             found       => undef,
2167             waitingdate => undef,
2168             expirationdate => $hold->patron_expiration_date,
2169             itemnumber  => $hold->item_level_hold ? $hold->itemnumber : undef,
2170         }
2171     )->store();
2172
2173     _FixPriority( { biblionumber => $hold->biblionumber } );
2174
2175     Koha::BackgroundJob::BatchUpdateBiblioHoldsQueue->new->enqueue(
2176         {
2177             biblio_ids => [ $hold->biblionumber ]
2178         }
2179     ) if C4::Context->preference('RealTimeHoldsQueue');
2180
2181
2182     return $hold;
2183 }
2184
2185 =head2 ReserveSlip
2186
2187 ReserveSlip(
2188     {
2189         branchcode     => $branchcode,
2190         borrowernumber => $borrowernumber,
2191         biblionumber   => $biblionumber,
2192         [ itemnumber   => $itemnumber, ]
2193         [ barcode      => $barcode, ]
2194     }
2195   )
2196
2197 Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
2198
2199 The letter code will be HOLD_SLIP, and the following tables are
2200 available within the slip:
2201
2202     reserves
2203     branches
2204     borrowers
2205     biblio
2206     biblioitems
2207     items
2208
2209 =cut
2210
2211 sub ReserveSlip {
2212     my ($args) = @_;
2213     my $branchcode     = $args->{branchcode};
2214     my $reserve_id = $args->{reserve_id};
2215
2216     my $hold = Koha::Holds->find($reserve_id);
2217     return unless $hold;
2218
2219     my $patron = $hold->borrower;
2220     my $reserve = $hold->unblessed;
2221
2222     return  C4::Letters::GetPreparedLetter (
2223         module => 'circulation',
2224         letter_code => 'HOLD_SLIP',
2225         branchcode => $branchcode,
2226         lang => $patron->lang,
2227         tables => {
2228             'reserves'    => $reserve,
2229             'branches'    => $reserve->{branchcode},
2230             'borrowers'   => $reserve->{borrowernumber},
2231             'biblio'      => $reserve->{biblionumber},
2232             'biblioitems' => $reserve->{biblionumber},
2233             'items'       => $reserve->{itemnumber},
2234         },
2235     );
2236 }
2237
2238 =head2 GetReservesControlBranch
2239
2240   my $reserves_control_branch = GetReservesControlBranch($item, $borrower);
2241
2242   Return the branchcode to be used to determine which reserves
2243   policy applies to a transaction.
2244
2245   C<$item> is a hashref for an item. Only 'homebranch' is used.
2246
2247   C<$borrower> is a hashref to borrower. Only 'branchcode' is used.
2248
2249 =cut
2250
2251 sub GetReservesControlBranch {
2252     my ( $item, $borrower ) = @_;
2253
2254     my $reserves_control = C4::Context->preference('ReservesControlBranch');
2255
2256     my $branchcode =
2257         ( $reserves_control eq 'ItemHomeLibrary' ) ? $item->{'homebranch'}
2258       : ( $reserves_control eq 'PatronLibrary' )   ? $borrower->{'branchcode'}
2259       :                                              undef;
2260
2261     return $branchcode;
2262 }
2263
2264 =head2 CalculatePriority
2265
2266     my $p = CalculatePriority($biblionumber, $resdate);
2267
2268 Calculate priority for a new reserve on biblionumber, placing it at
2269 the end of the line of all holds whose start date falls before
2270 the current system time and that are neither on the hold shelf
2271 or in transit.
2272
2273 The reserve date parameter is optional; if it is supplied, the
2274 priority is based on the set of holds whose start date falls before
2275 the parameter value.
2276
2277 After calculation of this priority, it is recommended to call
2278 _ShiftPriority. Note that this is currently done in
2279 AddReserves.
2280
2281 =cut
2282
2283 sub CalculatePriority {
2284     my ( $biblionumber, $resdate ) = @_;
2285
2286     my $sql = q{
2287         SELECT COUNT(*) FROM reserves
2288         WHERE biblionumber = ?
2289         AND   priority > 0
2290         AND   (found IS NULL OR found = '')
2291     };
2292     #skip found==W or found==T or found==P (waiting, transit or processing holds)
2293     if( $resdate ) {
2294         $sql.= ' AND ( reservedate <= ? )';
2295     }
2296     else {
2297         $sql.= ' AND ( reservedate < NOW() )';
2298     }
2299     my $dbh = C4::Context->dbh();
2300     my @row = $dbh->selectrow_array(
2301         $sql,
2302         undef,
2303         $resdate ? ($biblionumber, $resdate) : ($biblionumber)
2304     );
2305
2306     return @row ? $row[0]+1 : 1;
2307 }
2308
2309 =head2 IsItemOnHoldAndFound
2310
2311     my $bool = IsItemFoundHold( $itemnumber );
2312
2313     Returns true if the item is currently on hold
2314     and that hold has a non-null found status ( W, T, etc. )
2315
2316 =cut
2317
2318 sub IsItemOnHoldAndFound {
2319     my ($itemnumber) = @_;
2320
2321     my $rs = Koha::Database->new()->schema()->resultset('Reserve');
2322
2323     my $found = $rs->count(
2324         {
2325             itemnumber => $itemnumber,
2326             found      => { '!=' => undef }
2327         }
2328     );
2329
2330     return $found;
2331 }
2332
2333 =head2 GetMaxPatronHoldsForRecord
2334
2335 my $holds_per_record = ReservesControlBranch( $borrowernumber, $biblionumber );
2336
2337 For multiple holds on a given record for a given patron, the max
2338 number of record level holds that a patron can be placed is the highest
2339 value of the holds_per_record rule for each item if the record for that
2340 patron. This subroutine finds and returns the highest holds_per_record
2341 rule value for a given patron id and record id.
2342
2343 =cut
2344
2345 sub GetMaxPatronHoldsForRecord {
2346     my ( $borrowernumber, $biblionumber ) = @_;
2347
2348     my $patron = Koha::Patrons->find($borrowernumber);
2349     my @items = Koha::Items->search( { biblionumber => $biblionumber } )->as_list;
2350
2351     my $controlbranch = C4::Context->preference('ReservesControlBranch');
2352
2353     my $categorycode = $patron->categorycode;
2354     my $branchcode;
2355     $branchcode = $patron->branchcode if ( $controlbranch eq "PatronLibrary" );
2356
2357     my $max = 0;
2358     foreach my $item (@items) {
2359         my $itemtype = $item->effective_itemtype();
2360
2361         $branchcode = $item->homebranch if ( $controlbranch eq "ItemHomeLibrary" );
2362
2363         my $rule = Koha::CirculationRules->get_effective_rule({
2364             categorycode => $categorycode,
2365             itemtype     => $itemtype,
2366             branchcode   => $branchcode,
2367             rule_name    => 'holds_per_record'
2368         });
2369         my $holds_per_record = $rule ? $rule->rule_value : 0;
2370         $max = $holds_per_record if $holds_per_record > $max;
2371     }
2372
2373     return $max;
2374 }
2375
2376 =head1 AUTHOR
2377
2378 Koha Development Team <http://koha-community.org/>
2379
2380 =cut
2381
2382 1;