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