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