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