C4/Reserves.pm

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