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                 if ($res->{'found'} eq 'W') {
 736                     return ( "Waiting", $res, \@reserves ); # Found it, it is waiting
 737                 } else {
 738                     return ( "Reserved", $res, \@reserves ); # Found determinated hold, e. g. the tranferred one
 739                 }
 740             } else {
 741                 my $patron;
 742                 my $iteminfo;
 743                 my $local_hold_match;
 744
 745                 if ($LocalHoldsPriority) {
 746                     $patron = Koha::Patrons->find( $res->{borrowernumber} );
 747                     $iteminfo = C4::Items::GetItem($itemnumber);
 748
 749                     my $local_holds_priority_item_branchcode =
 750                       $iteminfo->{$LocalHoldsPriorityItemControl};
 751                     my $local_holds_priority_patron_branchcode =
 752                       ( $LocalHoldsPriorityPatronControl eq 'PickupLibrary' )
 753                       ? $res->{branchcode}
 754                       : ( $LocalHoldsPriorityPatronControl eq 'HomeLibrary' )
 755                       ? $patron->branchcode
 756                       : undef;
 757                     $local_hold_match =
 758                       $local_holds_priority_item_branchcode eq
 759                       $local_holds_priority_patron_branchcode;
 760                 }
 761
 762                 # See if this item is more important than what we've got so far
 763                 if ( ( $res->{'priority'} && $res->{'priority'} < $priority ) || $local_hold_match ) {
 764                     $iteminfo ||= C4::Items::GetItem($itemnumber);
 765                     next if $res->{itemtype} && $res->{itemtype} ne _get_itype( $iteminfo );
 766                     $patron ||= Koha::Patrons->find( $res->{borrowernumber} );
 767                     my $branch = GetReservesControlBranch( $iteminfo, $patron->unblessed );
 768                     my $branchitemrule = C4::Circulation::GetBranchItemRule($branch,$iteminfo->{'itype'});
 769                     next if ($branchitemrule->{'holdallowed'} == 0);
 770                     next if (($branchitemrule->{'holdallowed'} == 1) && ($branch ne $patron->branchcode));
 771                     next if ( ($branchitemrule->{hold_fulfillment_policy} ne 'any') && ($res->{branchcode} ne $iteminfo->{ $branchitemrule->{hold_fulfillment_policy} }) );
 772                     $priority = $res->{'priority'};
 773                     $highest  = $res;
 774                     last if $local_hold_match;
 775                 }
 776             }
 777         }
 778     }
 779
 780     # If we get this far, then no exact match was found.
 781     # We return the most important (i.e. next) reservation.
 782     if ($highest) {
 783         $highest->{'itemnumber'} = $item;
 784         return ( "Reserved", $highest, \@reserves );
 785     }
 786
 787     return ( '' );
 788 }
 789
 790 =head2 CancelExpiredReserves
 791
 792   CancelExpiredReserves();
 793
 794 Cancels all reserves with an expiration date from before today.
 795
 796 =cut
 797
 798 sub CancelExpiredReserves {
 799     my $today = dt_from_string();
 800     my $cancel_on_holidays = C4::Context->preference('ExpireReservesOnHolidays');
 801     my $expireWaiting = C4::Context->preference('ExpireReservesMaxPickUpDelay');
 802
 803     my $dtf = Koha::Database->new->schema->storage->datetime_parser;
 804     my $params = { expirationdate => { '<', $dtf->format_date($today) } };
 805     $params->{found} = undef unless $expireWaiting;
 806
 807     # FIXME To move to Koha::Holds->search_expired (?)
 808     my $holds = Koha::Holds->search( $params );
 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 ( $hold->found eq 'W' ) {
 817             $cancel_params->{charge_cancel_fee} = 1;
 818         }
 819         $hold->cancel( $cancel_params );
 820     }
 821 }
 822
 823 =head2 AutoUnsuspendReserves
 824
 825   AutoUnsuspendReserves();
 826
 827 Unsuspends all suspended reserves with a suspend_until date from before today.
 828
 829 =cut
 830
 831 sub AutoUnsuspendReserves {
 832     my $today = dt_from_string();
 833
 834     my @holds = Koha::Holds->search( { suspend_until => { '<' => $today->ymd() } } );
 835
 836     map { $_->suspend(0)->suspend_until(undef)->store() } @holds;
 837 }
 838
 839 =head2 ModReserve
 840
 841   ModReserve({ rank => $rank,
 842                reserve_id => $reserve_id,
 843                branchcode => $branchcode
 844                [, itemnumber => $itemnumber ]
 845                [, biblionumber => $biblionumber, $borrowernumber => $borrowernumber ]
 846               });
 847
 848 Change a hold request's priority or cancel it.
 849
 850 C<$rank> specifies the effect of the change.  If C<$rank>
 851 is 'W' or 'n', nothing happens.  This corresponds to leaving a
 852 request alone when changing its priority in the holds queue
 853 for a bib.
 854
 855 If C<$rank> is 'del', the hold request is cancelled.
 856
 857 If C<$rank> is an integer greater than zero, the priority of
 858 the request is set to that value.  Since priority != 0 means
 859 that the item is not waiting on the hold shelf, setting the
 860 priority to a non-zero value also sets the request's found
 861 status and waiting date to NULL.
 862
 863 The optional C<$itemnumber> parameter is used only when
 864 C<$rank> is a non-zero integer; if supplied, the itemnumber
 865 of the hold request is set accordingly; if omitted, the itemnumber
 866 is cleared.
 867
 868 B<FIXME:> Note that the forgoing can have the effect of causing
 869 item-level hold requests to turn into title-level requests.  This
 870 will be fixed once reserves has separate columns for requested
 871 itemnumber and supplying itemnumber.
 872
 873 =cut
 874
 875 sub ModReserve {
 876     my ( $params ) = @_;
 877
 878     my $rank = $params->{'rank'};
 879     my $reserve_id = $params->{'reserve_id'};
 880     my $branchcode = $params->{'branchcode'};
 881     my $itemnumber = $params->{'itemnumber'};
 882     my $suspend_until = $params->{'suspend_until'};
 883     my $borrowernumber = $params->{'borrowernumber'};
 884     my $biblionumber = $params->{'biblionumber'};
 885
 886     return if $rank eq "W";
 887     return if $rank eq "n";
 888
 889     return unless ( $reserve_id || ( $borrowernumber && ( $biblionumber || $itemnumber ) ) );
 890
 891     my $hold;
 892     unless ( $reserve_id ) {
 893         my $holds = Koha::Holds->search({ biblionumber => $biblionumber, borrowernumber => $borrowernumber, itemnumber => $itemnumber });
 894         return unless $holds->count; # FIXME Should raise an exception
 895         $hold = $holds->next;
 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
1165             my $circ_control_branch = C4::Circulation::_GetCircControlBranch( $i->unblessed(), $borrower );
1166             my $branchitemrule = C4::Circulation::GetBranchItemRule( $circ_control_branch, $i->itype );
1167
1168             $any_available = 1
1169               unless $i->itemlost
1170               || $i->notforloan > 0
1171               || $i->withdrawn
1172               || $i->onloan
1173               || IsItemOnHoldAndFound( $i->id )
1174               || ( $i->damaged
1175                 && !C4::Context->preference('AllowHoldsOnDamagedItems') )
1176               || Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
1177               || $branchitemrule->{holdallowed} == 1 && $borrower->{branchcode} ne $i->homebranch;
1178         }
1179
1180         return $any_available ? 0 : 1;
1181     }
1182
1183     return $item->{onloan} || GetReserveStatus($item->{itemnumber}) eq "Waiting";
1184 }
1185
1186 =head2 OnShelfHoldsAllowed
1187
1188   OnShelfHoldsAllowed($itemtype,$borrowercategory,$branchcode);
1189
1190 Checks issuingrules, using the borrowers categorycode, the itemtype, and branchcode to see if onshelf
1191 holds are allowed, returns true if so.
1192
1193 =cut
1194
1195 sub OnShelfHoldsAllowed {
1196     my ($item, $borrower) = @_;
1197
1198     my $itype = _get_itype($item);
1199     return _OnShelfHoldsAllowed($itype,$borrower->{categorycode},$item->{holdingbranch});
1200 }
1201
1202 sub _get_itype {
1203     my $item = shift;
1204
1205     my $itype;
1206     if (C4::Context->preference('item-level_itypes')) {
1207         # We can't trust GetItem to honour the syspref, so safest to do it ourselves
1208         # When GetItem is fixed, we can remove this
1209         $itype = $item->{itype};
1210     }
1211     else {
1212         # XXX This is a bit dodgy. It relies on biblio itemtype column having different name.
1213         # So if we already have a biblioitems join when calling this function,
1214         # we don't need to access the database again
1215         $itype = $item->{itemtype};
1216     }
1217     unless ($itype) {
1218         my $dbh = C4::Context->dbh;
1219         my $query = "SELECT itemtype FROM biblioitems WHERE biblioitemnumber = ? ";
1220         my $sth = $dbh->prepare($query);
1221         $sth->execute($item->{biblioitemnumber});
1222         if (my $data = $sth->fetchrow_hashref()){
1223             $itype = $data->{itemtype};
1224         }
1225     }
1226     return $itype;
1227 }
1228
1229 sub _OnShelfHoldsAllowed {
1230     my ($itype,$borrowercategory,$branchcode) = @_;
1231
1232     my $issuing_rule = Koha::IssuingRules->get_effective_issuing_rule({ categorycode => $borrowercategory, itemtype => $itype, branchcode => $branchcode });
1233     return $issuing_rule ? $issuing_rule->onshelfholds : undef;
1234 }
1235
1236 =head2 AlterPriority
1237
1238   AlterPriority( $where, $reserve_id );
1239
1240 This function changes a reserve's priority up, down, to the top, or to the bottom.
1241 Input: $where is 'up', 'down', 'top' or 'bottom'. Biblionumber, Date reserve was placed
1242
1243 =cut
1244
1245 sub AlterPriority {
1246     my ( $where, $reserve_id ) = @_;
1247
1248     my $hold = Koha::Holds->find( $reserve_id );
1249     return unless $hold;
1250
1251     if ( $hold->cancellationdate ) {
1252         warn "I cannot alter the priority for reserve_id $reserve_id, the reserve has been cancelled (" . $hold->cancellationdate . ')';
1253         return;
1254     }
1255
1256     if ( $where eq 'up' || $where eq 'down' ) {
1257
1258       my $priority = $hold->priority;
1259       $priority = $where eq 'up' ? $priority - 1 : $priority + 1;
1260       _FixPriority({ reserve_id => $reserve_id, rank => $priority })
1261
1262     } elsif ( $where eq 'top' ) {
1263
1264       _FixPriority({ reserve_id => $reserve_id, rank => '1' })
1265
1266     } elsif ( $where eq 'bottom' ) {
1267
1268       _FixPriority({ reserve_id => $reserve_id, rank => '999999' });
1269
1270     }
1271     # FIXME Should return the new priority
1272 }
1273
1274 =head2 ToggleLowestPriority
1275
1276   ToggleLowestPriority( $borrowernumber, $biblionumber );
1277
1278 This function sets the lowestPriority field to true if is false, and false if it is true.
1279
1280 =cut
1281
1282 sub ToggleLowestPriority {
1283     my ( $reserve_id ) = @_;
1284
1285     my $dbh = C4::Context->dbh;
1286
1287     my $sth = $dbh->prepare( "UPDATE reserves SET lowestPriority = NOT lowestPriority WHERE reserve_id = ?");
1288     $sth->execute( $reserve_id );
1289
1290     _FixPriority({ reserve_id => $reserve_id, rank => '999999' });
1291 }
1292
1293 =head2 ToggleSuspend
1294
1295   ToggleSuspend( $reserve_id );
1296
1297 This function sets the suspend field to true if is false, and false if it is true.
1298 If the reserve is currently suspended with a suspend_until date, that date will
1299 be cleared when it is unsuspended.
1300
1301 =cut
1302
1303 sub ToggleSuspend {
1304     my ( $reserve_id, $suspend_until ) = @_;
1305
1306     $suspend_until = dt_from_string($suspend_until) if ($suspend_until);
1307
1308     my $hold = Koha::Holds->find( $reserve_id );
1309
1310     if ( $hold->is_suspended ) {
1311         $hold->resume()
1312     } else {
1313         $hold->suspend_hold( $suspend_until );
1314     }
1315 }
1316
1317 =head2 SuspendAll
1318
1319   SuspendAll(
1320       borrowernumber   => $borrowernumber,
1321       [ biblionumber   => $biblionumber, ]
1322       [ suspend_until  => $suspend_until, ]
1323       [ suspend        => $suspend ]
1324   );
1325
1326   This function accepts a set of hash keys as its parameters.
1327   It requires either borrowernumber or biblionumber, or both.
1328
1329   suspend_until is wholly optional.
1330
1331 =cut
1332
1333 sub SuspendAll {
1334     my %params = @_;
1335
1336     my $borrowernumber = $params{'borrowernumber'} || undef;
1337     my $biblionumber   = $params{'biblionumber'}   || undef;
1338     my $suspend_until  = $params{'suspend_until'}  || undef;
1339     my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;
1340
1341     $suspend_until = eval { dt_from_string($suspend_until) }
1342       if ( defined($suspend_until) );
1343
1344     return unless ( $borrowernumber || $biblionumber );
1345
1346     my $params;
1347     $params->{found}          = undef;
1348     $params->{borrowernumber} = $borrowernumber if $borrowernumber;
1349     $params->{biblionumber}   = $biblionumber if $biblionumber;
1350
1351     my @holds = Koha::Holds->search($params);
1352
1353     if ($suspend) {
1354         map { $_->suspend_hold($suspend_until) } @holds;
1355     }
1356     else {
1357         map { $_->resume() } @holds;
1358     }
1359 }
1360
1361
1362 =head2 _FixPriority
1363
1364   _FixPriority({
1365     reserve_id => $reserve_id,
1366     [rank => $rank,]
1367     [ignoreSetLowestRank => $ignoreSetLowestRank]
1368   });
1369
1370   or
1371
1372   _FixPriority({ biblionumber => $biblionumber});
1373
1374 This routine adjusts the priority of a hold request and holds
1375 on the same bib.
1376
1377 In the first form, where a reserve_id is passed, the priority of the
1378 hold is set to supplied rank, and other holds for that bib are adjusted
1379 accordingly.  If the rank is "del", the hold is cancelled.  If no rank
1380 is supplied, all of the holds on that bib have their priority adjusted
1381 as if the second form had been used.
1382
1383 In the second form, where a biblionumber is passed, the holds on that
1384 bib (that are not captured) are sorted in order of increasing priority,
1385 then have reserves.priority set so that the first non-captured hold
1386 has its priority set to 1, the second non-captured hold has its priority
1387 set to 2, and so forth.
1388
1389 In both cases, holds that have the lowestPriority flag on are have their
1390 priority adjusted to ensure that they remain at the end of the line.
1391
1392 Note that the ignoreSetLowestRank parameter is meant to be used only
1393 when _FixPriority calls itself.
1394
1395 =cut
1396
1397 sub _FixPriority {
1398     my ( $params ) = @_;
1399     my $reserve_id = $params->{reserve_id};
1400     my $rank = $params->{rank} // '';
1401     my $ignoreSetLowestRank = $params->{ignoreSetLowestRank};
1402     my $biblionumber = $params->{biblionumber};
1403
1404     my $dbh = C4::Context->dbh;
1405
1406     my $hold;
1407     if ( $reserve_id ) {
1408         $hold = Koha::Holds->find( $reserve_id );
1409         return unless $hold;
1410     }
1411
1412     unless ( $biblionumber ) { # FIXME This is a very weird API
1413         $biblionumber = $hold->biblionumber;
1414     }
1415
1416     if ( $rank eq "del" ) { # FIXME will crash if called without $hold
1417         $hold->cancel;
1418     }
1419     elsif ( $rank eq "W" || $rank eq "0" ) {
1420
1421         # make sure priority for waiting or in-transit items is 0
1422         my $query = "
1423             UPDATE reserves
1424             SET    priority = 0
1425             WHERE reserve_id = ?
1426             AND found IN ('W', 'T')
1427         ";
1428         my $sth = $dbh->prepare($query);
1429         $sth->execute( $reserve_id );
1430     }
1431     my @priority;
1432
1433     # get whats left
1434     my $query = "
1435         SELECT reserve_id, borrowernumber, reservedate
1436         FROM   reserves
1437         WHERE  biblionumber   = ?
1438           AND  ((found <> 'W' AND found <> 'T') OR found IS NULL)
1439         ORDER BY priority ASC
1440     ";
1441     my $sth = $dbh->prepare($query);
1442     $sth->execute( $biblionumber );
1443     while ( my $line = $sth->fetchrow_hashref ) {
1444         push( @priority,     $line );
1445     }
1446
1447     # To find the matching index
1448     my $i;
1449     my $key = -1;    # to allow for 0 to be a valid result
1450     for ( $i = 0 ; $i < @priority ; $i++ ) {
1451         if ( $reserve_id == $priority[$i]->{'reserve_id'} ) {
1452             $key = $i;    # save the index
1453             last;
1454         }
1455     }
1456
1457     # if index exists in array then move it to new position
1458     if ( $key > -1 && $rank ne 'del' && $rank > 0 ) {
1459         my $new_rank = $rank -
1460           1;    # $new_rank is what you want the new index to be in the array
1461         my $moving_item = splice( @priority, $key, 1 );
1462         splice( @priority, $new_rank, 0, $moving_item );
1463     }
1464
1465     # now fix the priority on those that are left....
1466     $query = "
1467         UPDATE reserves
1468         SET    priority = ?
1469         WHERE  reserve_id = ?
1470     ";
1471     $sth = $dbh->prepare($query);
1472     for ( my $j = 0 ; $j < @priority ; $j++ ) {
1473         $sth->execute(
1474             $j + 1,
1475             $priority[$j]->{'reserve_id'}
1476         );
1477     }
1478
1479     $sth = $dbh->prepare( "SELECT reserve_id FROM reserves WHERE lowestPriority = 1 ORDER BY priority" );
1480     $sth->execute();
1481
1482     unless ( $ignoreSetLowestRank ) {
1483       while ( my $res = $sth->fetchrow_hashref() ) {
1484         _FixPriority({
1485             reserve_id => $res->{'reserve_id'},
1486             rank => '999999',
1487             ignoreSetLowestRank => 1
1488         });
1489       }
1490     }
1491 }
1492
1493 =head2 _Findgroupreserve
1494
1495   @results = &_Findgroupreserve($biblioitemnumber, $biblionumber, $itemnumber, $lookahead, $ignore_borrowers);
1496
1497 Looks for a holds-queue based item-specific match first, then for a holds-queue title-level match, returning the
1498 first match found.  If neither, then we look for non-holds-queue based holds.
1499 Lookahead is the number of days to look in advance.
1500
1501 C<&_Findgroupreserve> returns :
1502 C<@results> is an array of references-to-hash whose keys are mostly
1503 fields from the reserves table of the Koha database, plus
1504 C<biblioitemnumber>.
1505
1506 =cut
1507
1508 sub _Findgroupreserve {
1509     my ( $bibitem, $biblio, $itemnumber, $lookahead, $ignore_borrowers) = @_;
1510     my $dbh   = C4::Context->dbh;
1511
1512     # TODO: consolidate at least the SELECT portion of the first 2 queries to a common $select var.
1513     # check for exact targeted match
1514     my $item_level_target_query = qq{
1515         SELECT reserves.biblionumber        AS biblionumber,
1516                reserves.borrowernumber      AS borrowernumber,
1517                reserves.reservedate         AS reservedate,
1518                reserves.branchcode          AS branchcode,
1519                reserves.cancellationdate    AS cancellationdate,
1520                reserves.found               AS found,
1521                reserves.reservenotes        AS reservenotes,
1522                reserves.priority            AS priority,
1523                reserves.timestamp           AS timestamp,
1524                biblioitems.biblioitemnumber AS biblioitemnumber,
1525                reserves.itemnumber          AS itemnumber,
1526                reserves.reserve_id          AS reserve_id,
1527                reserves.itemtype            AS itemtype
1528         FROM reserves
1529         JOIN biblioitems USING (biblionumber)
1530         JOIN hold_fill_targets USING (biblionumber, borrowernumber, itemnumber)
1531         WHERE found IS NULL
1532         AND priority > 0
1533         AND item_level_request = 1
1534         AND itemnumber = ?
1535         AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1536         AND suspend = 0
1537         ORDER BY priority
1538     };
1539     my $sth = $dbh->prepare($item_level_target_query);
1540     $sth->execute($itemnumber, $lookahead||0);
1541     my @results;
1542     if ( my $data = $sth->fetchrow_hashref ) {
1543         push( @results, $data )
1544           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1545     }
1546     return @results if @results;
1547
1548     # check for title-level targeted match
1549     my $title_level_target_query = qq{
1550         SELECT reserves.biblionumber        AS biblionumber,
1551                reserves.borrowernumber      AS borrowernumber,
1552                reserves.reservedate         AS reservedate,
1553                reserves.branchcode          AS branchcode,
1554                reserves.cancellationdate    AS cancellationdate,
1555                reserves.found               AS found,
1556                reserves.reservenotes        AS reservenotes,
1557                reserves.priority            AS priority,
1558                reserves.timestamp           AS timestamp,
1559                biblioitems.biblioitemnumber AS biblioitemnumber,
1560                reserves.itemnumber          AS itemnumber,
1561                reserves.reserve_id          AS reserve_id,
1562                reserves.itemtype            AS itemtype
1563         FROM reserves
1564         JOIN biblioitems USING (biblionumber)
1565         JOIN hold_fill_targets USING (biblionumber, borrowernumber)
1566         WHERE found IS NULL
1567         AND priority > 0
1568         AND item_level_request = 0
1569         AND hold_fill_targets.itemnumber = ?
1570         AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1571         AND suspend = 0
1572         ORDER BY priority
1573     };
1574     $sth = $dbh->prepare($title_level_target_query);
1575     $sth->execute($itemnumber, $lookahead||0);
1576     @results = ();
1577     if ( my $data = $sth->fetchrow_hashref ) {
1578         push( @results, $data )
1579           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1580     }
1581     return @results if @results;
1582
1583     my $query = qq{
1584         SELECT reserves.biblionumber               AS biblionumber,
1585                reserves.borrowernumber             AS borrowernumber,
1586                reserves.reservedate                AS reservedate,
1587                reserves.waitingdate                AS waitingdate,
1588                reserves.branchcode                 AS branchcode,
1589                reserves.cancellationdate           AS cancellationdate,
1590                reserves.found                      AS found,
1591                reserves.reservenotes               AS reservenotes,
1592                reserves.priority                   AS priority,
1593                reserves.timestamp                  AS timestamp,
1594                reserves.itemnumber                 AS itemnumber,
1595                reserves.reserve_id                 AS reserve_id,
1596                reserves.itemtype                   AS itemtype
1597         FROM reserves
1598         WHERE reserves.biblionumber = ?
1599           AND (reserves.itemnumber IS NULL OR reserves.itemnumber = ?)
1600           AND reserves.reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1601           AND suspend = 0
1602           ORDER BY priority
1603     };
1604     $sth = $dbh->prepare($query);
1605     $sth->execute( $biblio, $itemnumber, $lookahead||0);
1606     @results = ();
1607     while ( my $data = $sth->fetchrow_hashref ) {
1608         push( @results, $data )
1609           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1610     }
1611     return @results;
1612 }
1613
1614 =head2 _koha_notify_reserve
1615
1616   _koha_notify_reserve( $hold->reserve_id );
1617
1618 Sends a notification to the patron that their hold has been filled (through
1619 ModReserveAffect, _not_ ModReserveFill)
1620
1621 The letter code for this notice may be found using the following query:
1622
1623     select distinct letter_code
1624     from message_transports
1625     inner join message_attributes using (message_attribute_id)
1626     where message_name = 'Hold_Filled'
1627
1628 This will probably sipmly be 'HOLD', but because it is defined in the database,
1629 it is subject to addition or change.
1630
1631 The following tables are availalbe witin the notice:
1632
1633     branches
1634     borrowers
1635     biblio
1636     biblioitems
1637     reserves
1638     items
1639
1640 =cut
1641
1642 sub _koha_notify_reserve {
1643     my $reserve_id = shift;
1644     my $hold = Koha::Holds->find($reserve_id);
1645     my $borrowernumber = $hold->borrowernumber;
1646
1647     my $patron = Koha::Patrons->find( $borrowernumber );
1648
1649     # Try to get the borrower's email address
1650     my $to_address = C4::Members::GetNoticeEmailAddress($borrowernumber);
1651
1652     my $messagingprefs = C4::Members::Messaging::GetMessagingPreferences( {
1653             borrowernumber => $borrowernumber,
1654             message_name => 'Hold_Filled'
1655     } );
1656
1657     my $library = Koha::Libraries->find( $hold->branchcode )->unblessed;
1658
1659     my $admin_email_address = $library->{branchemail} || C4::Context->preference('KohaAdminEmailAddress');
1660
1661     my %letter_params = (
1662         module => 'reserves',
1663         branchcode => $hold->branchcode,
1664         lang => $patron->lang,
1665         tables => {
1666             'branches'       => $library,
1667             'borrowers'      => $patron->unblessed,
1668             'biblio'         => $hold->biblionumber,
1669             'biblioitems'    => $hold->biblionumber,
1670             'reserves'       => $hold->unblessed,
1671             'items'          => $hold->itemnumber,
1672         },
1673     );
1674
1675     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.
1676     my $send_notification = sub {
1677         my ( $mtt, $letter_code ) = (@_);
1678         return unless defined $letter_code;
1679         $letter_params{letter_code} = $letter_code;
1680         $letter_params{message_transport_type} = $mtt;
1681         my $letter =  C4::Letters::GetPreparedLetter ( %letter_params );
1682         unless ($letter) {
1683             warn "Could not find a letter called '$letter_params{'letter_code'}' for $mtt in the 'reserves' module";
1684             return;
1685         }
1686
1687         C4::Letters::EnqueueLetter( {
1688             letter => $letter,
1689             borrowernumber => $borrowernumber,
1690             from_address => $admin_email_address,
1691             message_transport_type => $mtt,
1692         } );
1693     };
1694
1695     while ( my ( $mtt, $letter_code ) = each %{ $messagingprefs->{transports} } ) {
1696         next if (
1697                ( $mtt eq 'email' and not $to_address ) # No email address
1698             or ( $mtt eq 'sms'   and not $patron->smsalertnumber ) # No SMS number
1699             or ( $mtt eq 'phone' and C4::Context->preference('TalkingTechItivaPhoneNotification') ) # Notice is handled by TalkingTech_itiva_outbound.pl
1700         );
1701
1702         &$send_notification($mtt, $letter_code);
1703         $notification_sent++;
1704     }
1705     #Making sure that a print notification is sent if no other transport types can be utilized.
1706     if (! $notification_sent) {
1707         &$send_notification('print', 'HOLD');
1708     }
1709
1710 }
1711
1712 =head2 _ShiftPriorityByDateAndPriority
1713
1714   $new_priority = _ShiftPriorityByDateAndPriority( $biblionumber, $reservedate, $priority );
1715
1716 This increments the priority of all reserves after the one
1717 with either the lowest date after C<$reservedate>
1718 or the lowest priority after C<$priority>.
1719
1720 It effectively makes room for a new reserve to be inserted with a certain
1721 priority, which is returned.
1722
1723 This is most useful when the reservedate can be set by the user.  It allows
1724 the new reserve to be placed before other reserves that have a later
1725 reservedate.  Since priority also is set by the form in reserves/request.pl
1726 the sub accounts for that too.
1727
1728 =cut
1729
1730 sub _ShiftPriorityByDateAndPriority {
1731     my ( $biblio, $resdate, $new_priority ) = @_;
1732
1733     my $dbh = C4::Context->dbh;
1734     my $query = "SELECT priority FROM reserves WHERE biblionumber = ? AND ( reservedate > ? OR priority > ? ) ORDER BY priority ASC LIMIT 1";
1735     my $sth = $dbh->prepare( $query );
1736     $sth->execute( $biblio, $resdate, $new_priority );
1737     my $min_priority = $sth->fetchrow;
1738     # if no such matches are found, $new_priority remains as original value
1739     $new_priority = $min_priority if ( $min_priority );
1740
1741     # Shift the priority up by one; works in conjunction with the next SQL statement
1742     $query = "UPDATE reserves
1743               SET priority = priority+1
1744               WHERE biblionumber = ?
1745               AND borrowernumber = ?
1746               AND reservedate = ?
1747               AND found IS NULL";
1748     my $sth_update = $dbh->prepare( $query );
1749
1750     # Select all reserves for the biblio with priority greater than $new_priority, and order greatest to least
1751     $query = "SELECT borrowernumber, reservedate FROM reserves WHERE priority >= ? AND biblionumber = ? ORDER BY priority DESC";
1752     $sth = $dbh->prepare( $query );
1753     $sth->execute( $new_priority, $biblio );
1754     while ( my $row = $sth->fetchrow_hashref ) {
1755         $sth_update->execute( $biblio, $row->{borrowernumber}, $row->{reservedate} );
1756     }
1757
1758     return $new_priority;  # so the caller knows what priority they wind up receiving
1759 }
1760
1761 =head2 OPACItemHoldsAllowed
1762
1763   OPACItemHoldsAllowed($item_record,$borrower_record);
1764
1765 Checks issuingrules, using the borrowers categorycode, the itemtype, and branchcode to see
1766 if specific item holds are allowed, returns true if so.
1767
1768 =cut
1769
1770 sub OPACItemHoldsAllowed {
1771     my ($item,$borrower) = @_;
1772
1773     my $branchcode = $item->{homebranch} or die "No homebranch";
1774     my $itype;
1775     my $dbh = C4::Context->dbh;
1776     if (C4::Context->preference('item-level_itypes')) {
1777        # We can't trust GetItem to honour the syspref, so safest to do it ourselves
1778        # When GetItem is fixed, we can remove this
1779        $itype = $item->{itype};
1780     }
1781     else {
1782        my $query = "SELECT itemtype FROM biblioitems WHERE biblioitemnumber = ? ";
1783        my $sth = $dbh->prepare($query);
1784        $sth->execute($item->{biblioitemnumber});
1785        if (my $data = $sth->fetchrow_hashref()){
1786            $itype = $data->{itemtype};
1787        }
1788     }
1789
1790     my $query = "SELECT opacitemholds,categorycode,itemtype,branchcode FROM issuingrules WHERE
1791           (issuingrules.categorycode = ? OR issuingrules.categorycode = '*')
1792         AND
1793           (issuingrules.itemtype = ? OR issuingrules.itemtype = '*')
1794         AND
1795           (issuingrules.branchcode = ? OR issuingrules.branchcode = '*')
1796         ORDER BY
1797           issuingrules.categorycode desc,
1798           issuingrules.itemtype desc,
1799           issuingrules.branchcode desc
1800        LIMIT 1";
1801     my $sth = $dbh->prepare($query);
1802     $sth->execute($borrower->{categorycode},$itype,$branchcode);
1803     my $data = $sth->fetchrow_hashref;
1804     my $opacitemholds = uc substr ($data->{opacitemholds}, 0, 1);
1805     return '' if $opacitemholds eq 'N';
1806     return $opacitemholds;
1807 }
1808
1809 =head2 MoveReserve
1810
1811   MoveReserve( $itemnumber, $borrowernumber, $cancelreserve )
1812
1813 Use when checking out an item to handle reserves
1814 If $cancelreserve boolean is set to true, it will remove existing reserve
1815
1816 =cut
1817
1818 sub MoveReserve {
1819     my ( $itemnumber, $borrowernumber, $cancelreserve ) = @_;
1820
1821     my $lookahead = C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
1822     my ( $restype, $res, $all_reserves ) = CheckReserves( $itemnumber, undef, $lookahead );
1823     return unless $res;
1824
1825     my $biblionumber     =  $res->{biblionumber};
1826
1827     if ($res->{borrowernumber} == $borrowernumber) {
1828         ModReserveFill($res);
1829     }
1830     else {
1831         # warn "Reserved";
1832         # The item is reserved by someone else.
1833         # Find this item in the reserves
1834
1835         my $borr_res;
1836         foreach (@$all_reserves) {
1837             $_->{'borrowernumber'} == $borrowernumber or next;
1838             $_->{'biblionumber'}   == $biblionumber   or next;
1839
1840             $borr_res = $_;
1841             last;
1842         }
1843
1844         if ( $borr_res ) {
1845             # The item is reserved by the current patron
1846             ModReserveFill($borr_res);
1847         }
1848
1849         if ( $cancelreserve eq 'revert' ) { ## Revert waiting reserve to priority 1
1850             RevertWaitingStatus({ itemnumber => $itemnumber });
1851         }
1852         elsif ( $cancelreserve eq 'cancel' || $cancelreserve ) { # cancel reserves on this item
1853             my $hold = Koha::Holds->find( $res->{reserve_id} );
1854             $hold->cancel;
1855         }
1856     }
1857 }
1858
1859 =head2 MergeHolds
1860
1861   MergeHolds($dbh,$to_biblio, $from_biblio);
1862
1863 This shifts the holds from C<$from_biblio> to C<$to_biblio> and reorders them by the date they were placed
1864
1865 =cut
1866
1867 sub MergeHolds {
1868     my ( $dbh, $to_biblio, $from_biblio ) = @_;
1869     my $sth = $dbh->prepare(
1870         "SELECT count(*) as reserve_count FROM reserves WHERE biblionumber = ?"
1871     );
1872     $sth->execute($from_biblio);
1873     if ( my $data = $sth->fetchrow_hashref() ) {
1874
1875         # holds exist on old record, if not we don't need to do anything
1876         $sth = $dbh->prepare(
1877             "UPDATE reserves SET biblionumber = ? WHERE biblionumber = ?");
1878         $sth->execute( $to_biblio, $from_biblio );
1879
1880         # Reorder by date
1881         # don't reorder those already waiting
1882
1883         $sth = $dbh->prepare(
1884 "SELECT * FROM reserves WHERE biblionumber = ? AND (found <> ? AND found <> ? OR found is NULL) ORDER BY reservedate ASC"
1885         );
1886         my $upd_sth = $dbh->prepare(
1887 "UPDATE reserves SET priority = ? WHERE biblionumber = ? AND borrowernumber = ?
1888         AND reservedate = ? AND (itemnumber = ? or itemnumber is NULL) "
1889         );
1890         $sth->execute( $to_biblio, 'W', 'T' );
1891         my $priority = 1;
1892         while ( my $reserve = $sth->fetchrow_hashref() ) {
1893             $upd_sth->execute(
1894                 $priority,                    $to_biblio,
1895                 $reserve->{'borrowernumber'}, $reserve->{'reservedate'},
1896                 $reserve->{'itemnumber'}
1897             );
1898             $priority++;
1899         }
1900     }
1901 }
1902
1903 =head2 RevertWaitingStatus
1904
1905   RevertWaitingStatus({ itemnumber => $itemnumber });
1906
1907   Reverts a 'waiting' hold back to a regular hold with a priority of 1.
1908
1909   Caveat: Any waiting hold fixed with RevertWaitingStatus will be an
1910           item level hold, even if it was only a bibliolevel hold to
1911           begin with. This is because we can no longer know if a hold
1912           was item-level or bib-level after a hold has been set to
1913           waiting status.
1914
1915 =cut
1916
1917 sub RevertWaitingStatus {
1918     my ( $params ) = @_;
1919     my $itemnumber = $params->{'itemnumber'};
1920
1921     return unless ( $itemnumber );
1922
1923     my $dbh = C4::Context->dbh;
1924
1925     ## Get the waiting reserve we want to revert
1926     my $query = "
1927         SELECT * FROM reserves
1928         WHERE itemnumber = ?
1929         AND found IS NOT NULL
1930     ";
1931     my $sth = $dbh->prepare( $query );
1932     $sth->execute( $itemnumber );
1933     my $reserve = $sth->fetchrow_hashref();
1934
1935     ## Increment the priority of all other non-waiting
1936     ## reserves for this bib record
1937     $query = "
1938         UPDATE reserves
1939         SET
1940           priority = priority + 1
1941         WHERE
1942           biblionumber =  ?
1943         AND
1944           priority > 0
1945     ";
1946     $sth = $dbh->prepare( $query );
1947     $sth->execute( $reserve->{'biblionumber'} );
1948
1949     ## Fix up the currently waiting reserve
1950     $query = "
1951     UPDATE reserves
1952     SET
1953       priority = 1,
1954       found = NULL,
1955       waitingdate = NULL
1956     WHERE
1957       reserve_id = ?
1958     ";
1959     $sth = $dbh->prepare( $query );
1960     $sth->execute( $reserve->{'reserve_id'} );
1961     _FixPriority( { biblionumber => $reserve->{biblionumber} } );
1962 }
1963
1964 =head2 ReserveSlip
1965
1966   ReserveSlip($branchcode, $borrowernumber, $biblionumber)
1967
1968 Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
1969
1970 The letter code will be HOLD_SLIP, and the following tables are
1971 available within the slip:
1972
1973     reserves
1974     branches
1975     borrowers
1976     biblio
1977     biblioitems
1978     items
1979
1980 =cut
1981
1982 sub ReserveSlip {
1983     my ($branch, $borrowernumber, $biblionumber) = @_;
1984
1985 #   return unless ( C4::Context->boolean_preference('printreserveslips') );
1986     my $patron = Koha::Patrons->find( $borrowernumber );
1987
1988     my $hold = Koha::Holds->search({biblionumber => $biblionumber, borrowernumber => $borrowernumber })->next;
1989     return unless $hold;
1990     my $reserve = $hold->unblessed;
1991
1992     return  C4::Letters::GetPreparedLetter (
1993         module => 'circulation',
1994         letter_code => 'HOLD_SLIP',
1995         branchcode => $branch,
1996         lang => $patron->lang,
1997         tables => {
1998             'reserves'    => $reserve,
1999             'branches'    => $reserve->{branchcode},
2000             'borrowers'   => $reserve->{borrowernumber},
2001             'biblio'      => $reserve->{biblionumber},
2002             'biblioitems' => $reserve->{biblionumber},
2003             'items'       => $reserve->{itemnumber},
2004         },
2005     );
2006 }
2007
2008 =head2 GetReservesControlBranch
2009
2010   my $reserves_control_branch = GetReservesControlBranch($item, $borrower);
2011
2012   Return the branchcode to be used to determine which reserves
2013   policy applies to a transaction.
2014
2015   C<$item> is a hashref for an item. Only 'homebranch' is used.
2016
2017   C<$borrower> is a hashref to borrower. Only 'branchcode' is used.
2018
2019 =cut
2020
2021 sub GetReservesControlBranch {
2022     my ( $item, $borrower ) = @_;
2023
2024     my $reserves_control = C4::Context->preference('ReservesControlBranch');
2025
2026     my $branchcode =
2027         ( $reserves_control eq 'ItemHomeLibrary' ) ? $item->{'homebranch'}
2028       : ( $reserves_control eq 'PatronLibrary' )   ? $borrower->{'branchcode'}
2029       :                                              undef;
2030
2031     return $branchcode;
2032 }
2033
2034 =head2 CalculatePriority
2035
2036     my $p = CalculatePriority($biblionumber, $resdate);
2037
2038 Calculate priority for a new reserve on biblionumber, placing it at
2039 the end of the line of all holds whose start date falls before
2040 the current system time and that are neither on the hold shelf
2041 or in transit.
2042
2043 The reserve date parameter is optional; if it is supplied, the
2044 priority is based on the set of holds whose start date falls before
2045 the parameter value.
2046
2047 After calculation of this priority, it is recommended to call
2048 _ShiftPriorityByDateAndPriority. Note that this is currently done in
2049 AddReserves.
2050
2051 =cut
2052
2053 sub CalculatePriority {
2054     my ( $biblionumber, $resdate ) = @_;
2055
2056     my $sql = q{
2057         SELECT COUNT(*) FROM reserves
2058         WHERE biblionumber = ?
2059         AND   priority > 0
2060         AND   (found IS NULL OR found = '')
2061     };
2062     #skip found==W or found==T (waiting or transit holds)
2063     if( $resdate ) {
2064         $sql.= ' AND ( reservedate <= ? )';
2065     }
2066     else {
2067         $sql.= ' AND ( reservedate < NOW() )';
2068     }
2069     my $dbh = C4::Context->dbh();
2070     my @row = $dbh->selectrow_array(
2071         $sql,
2072         undef,
2073         $resdate ? ($biblionumber, $resdate) : ($biblionumber)
2074     );
2075
2076     return @row ? $row[0]+1 : 1;
2077 }
2078
2079 =head2 IsItemOnHoldAndFound
2080
2081     my $bool = IsItemFoundHold( $itemnumber );
2082
2083     Returns true if the item is currently on hold
2084     and that hold has a non-null found status ( W, T, etc. )
2085
2086 =cut
2087
2088 sub IsItemOnHoldAndFound {
2089     my ($itemnumber) = @_;
2090
2091     my $rs = Koha::Database->new()->schema()->resultset('Reserve');
2092
2093     my $found = $rs->count(
2094         {
2095             itemnumber => $itemnumber,
2096             found      => { '!=' => undef }
2097         }
2098     );
2099
2100     return $found;
2101 }
2102
2103 =head2 GetMaxPatronHoldsForRecord
2104
2105 my $holds_per_record = ReservesControlBranch( $borrowernumber, $biblionumber );
2106
2107 For multiple holds on a given record for a given patron, the max
2108 number of record level holds that a patron can be placed is the highest
2109 value of the holds_per_record rule for each item if the record for that
2110 patron. This subroutine finds and returns the highest holds_per_record
2111 rule value for a given patron id and record id.
2112
2113 =cut
2114
2115 sub GetMaxPatronHoldsForRecord {
2116     my ( $borrowernumber, $biblionumber ) = @_;
2117
2118     my $patron = Koha::Patrons->find($borrowernumber);
2119     my @items = Koha::Items->search( { biblionumber => $biblionumber } );
2120
2121     my $controlbranch = C4::Context->preference('ReservesControlBranch');
2122
2123     my $categorycode = $patron->categorycode;
2124     my $branchcode;
2125     $branchcode = $patron->branchcode if ( $controlbranch eq "PatronLibrary" );
2126
2127     my $max = 0;
2128     foreach my $item (@items) {
2129         my $itemtype = $item->effective_itemtype();
2130
2131         $branchcode = $item->homebranch if ( $controlbranch eq "ItemHomeLibrary" );
2132
2133         my $rule = GetHoldRule( $categorycode, $itemtype, $branchcode );
2134         my $holds_per_record = $rule ? $rule->{holds_per_record} : 0;
2135         $max = $holds_per_record if $holds_per_record > $max;
2136     }
2137
2138     return $max;
2139 }
2140
2141 =head2 GetHoldRule
2142
2143 my $rule = GetHoldRule( $categorycode, $itemtype, $branchcode );
2144
2145 Returns the matching hold related issuingrule fields for a given
2146 patron category, itemtype, and library.
2147
2148 =cut
2149
2150 sub GetHoldRule {
2151     my ( $categorycode, $itemtype, $branchcode ) = @_;
2152
2153     my $dbh = C4::Context->dbh;
2154
2155     my $sth = $dbh->prepare(
2156         q{
2157          SELECT categorycode, itemtype, branchcode, reservesallowed, holds_per_record
2158            FROM issuingrules
2159           WHERE (categorycode in (?,'*') )
2160             AND (itemtype IN (?,'*'))
2161             AND (branchcode IN (?,'*'))
2162        ORDER BY categorycode DESC,
2163                 itemtype     DESC,
2164                 branchcode   DESC
2165         }
2166     );
2167
2168     $sth->execute( $categorycode, $itemtype, $branchcode );
2169
2170     return $sth->fetchrow_hashref();
2171 }
2172
2173 =head1 AUTHOR
2174
2175 Koha Development Team <http://koha-community.org/>
2176
2177 =cut
2178
2179 1;