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