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