C4/Reserves.pm

   1 package C4::Reserves;
   2
   3 # Copyright 2000-2002 Katipo Communications
   4 #           2006 SAN Ouest Provence
   5 #           2007-2010 BibLibre Paul POULAIN
   6 #           2011 Catalyst IT
   7 #
   8 # This file is part of Koha.
   9 #
  10 # Koha is free software; you can redistribute it and/or modify it
  11 # under the terms of the GNU General Public License as published by
  12 # the Free Software Foundation; either version 3 of the License, or
  13 # (at your option) any later version.
  14 #
  15 # Koha is distributed in the hope that it will be useful, but
  16 # WITHOUT ANY WARRANTY; without even the implied warranty of
  17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18 # GNU General Public License for more details.
  19 #
  20 # You should have received a copy of the GNU General Public License
  21 # along with Koha; if not, see <http://www.gnu.org/licenses>.
  22
  23
  24 use Modern::Perl;
  25
  26 use C4::Accounts;
  27 use C4::Biblio;
  28 use C4::Circulation;
  29 use C4::Context;
  30 use C4::Items;
  31 use C4::Letters;
  32 use C4::Log;
  33 use C4::Members::Messaging;
  34 use C4::Members;
  35 use Koha::Account::Lines;
  36 use Koha::Biblios;
  37 use Koha::Calendar;
  38 use Koha::CirculationRules;
  39 use Koha::Database;
  40 use Koha::DateUtils;
  41 use Koha::Hold;
  42 use Koha::Holds;
  43 use Koha::ItemTypes;
  44 use Koha::Items;
  45 use Koha::Libraries;
  46 use Koha::Old::Hold;
  47 use Koha::Patrons;
  48 use Koha::Plugins;
  49
  50 use Carp;
  51 use Data::Dumper;
  52 use List::MoreUtils qw( firstidx any );
  53
  54 use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS);
  55
  56 =head1 NAME
  57
  58 C4::Reserves - Koha functions for dealing with reservation.
  59
  60 =head1 SYNOPSIS
  61
  62   use C4::Reserves;
  63
  64 =head1 DESCRIPTION
  65
  66 This modules provides somes functions to deal with reservations.
  67
  68   Reserves are stored in reserves table.
  69   The following columns contains important values :
  70   - priority >0      : then the reserve is at 1st stage, and not yet affected to any item.
  71              =0      : then the reserve is being dealed
  72   - found : NULL         : means the patron requested the 1st available, and we haven't chosen the item
  73             T(ransit)    : the reserve is linked to an item but is in transit to the pickup branch
  74             W(aiting)    : the reserve is linked to an item, is at the pickup branch, and is waiting on the hold shelf
  75             F(inished)   : the reserve has been completed, and is done
  76             P(rocessing) : reserved item has been returned using self-check machine and reserve needs to be confirmed
  77                            by librarian before notice is send and status changed to waiting.
  78                            Applicable only if HoldsNeedProcessingSIP system preference is set.
  79   - itemnumber : empty : the reserve is still unaffected to an item
  80                  filled: the reserve is attached to an item
  81   The complete workflow is :
  82   ==== 1st use case ====
  83   patron request a document, 1st available :                      P >0, F=NULL, I=NULL
  84   a library having it run "transfertodo", and clic on the list
  85          if there is no transfer to do, the reserve waiting
  86          patron can pick it up                                    P =0, F=W,    I=filled
  87          if there is a transfer to do, write in branchtransfer    P =0, F=T,    I=filled
  88            The pickup library receive the book, it check in       P =0, F=W,    I=filled
  89   The patron borrow the book                                      P =0, F=F,    I=filled
  90
  91   ==== 2nd use case ====
  92   patron requests a document, a given item,
  93     If pickup is holding branch                                   P =0, F=W,   I=filled
  94     If transfer needed, write in branchtransfer                   P =0, F=T,    I=filled
  95         The pickup library receive the book, it checks it in      P =0, F=W,    I=filled
  96   The patron borrow the book                                      P =0, F=F,    I=filled
  97
  98 =head1 FUNCTIONS
  99
 100 =cut
 101
 102 BEGIN {
 103     require Exporter;
 104     @ISA = qw(Exporter);
 105     @EXPORT = qw(
 106         &AddReserve
 107
 108         &GetReserveStatus
 109
 110         &GetOtherReserves
 111
 112         &ModReserveFill
 113         &ModReserveAffect
 114         &ModReserve
 115         &ModReserveStatus
 116         &ModReserveCancelAll
 117         &ModReserveMinusPriority
 118         &MoveReserve
 119
 120         &CheckReserves
 121         &CanBookBeReserved
 122         &CanItemBeReserved
 123         &CanReserveBeCanceledFromOpac
 124         &CancelExpiredReserves
 125
 126         &AutoUnsuspendReserves
 127
 128         &IsAvailableForItemLevelRequest
 129         ItemsAnyAvailableAndNotRestricted
 130
 131         &AlterPriority
 132         &ToggleLowestPriority
 133
 134         &ReserveSlip
 135         &ToggleSuspend
 136         &SuspendAll
 137
 138         &GetReservesControlBranch
 139
 140         IsItemOnHoldAndFound
 141
 142         GetMaxPatronHoldsForRecord
 143     );
 144     @EXPORT_OK = qw( MergeHolds );
 145 }
 146
 147 =head2 AddReserve
 148
 149     AddReserve(
 150         {
 151             branchcode       => $branchcode,
 152             borrowernumber   => $borrowernumber,
 153             biblionumber     => $biblionumber,
 154             priority         => $priority,
 155             reservation_date => $reservation_date,
 156             expiration_date  => $expiration_date,
 157             notes            => $notes,
 158             title            => $title,
 159             itemnumber       => $itemnumber,
 160             found            => $found,
 161             itemtype         => $itemtype,
 162         }
 163     );
 164
 165 Adds reserve and generates HOLDPLACED message.
 166
 167 The following tables are available witin the HOLDPLACED message:
 168
 169     branches
 170     borrowers
 171     biblio
 172     biblioitems
 173     items
 174     reserves
 175
 176 =cut
 177
 178 sub AddReserve {
 179     my ($params)       = @_;
 180     my $branch         = $params->{branchcode};
 181     my $borrowernumber = $params->{borrowernumber};
 182     my $biblionumber   = $params->{biblionumber};
 183     my $priority       = $params->{priority};
 184     my $resdate        = $params->{reservation_date};
 185     my $expdate        = $params->{expiration_date};
 186     my $notes          = $params->{notes};
 187     my $title          = $params->{title};
 188     my $checkitem      = $params->{itemnumber};
 189     my $found          = $params->{found};
 190     my $itemtype       = $params->{itemtype};
 191     my $non_priority   = $params->{non_priority};
 192
 193     $resdate = output_pref( { str => dt_from_string( $resdate ), dateonly => 1, dateformat => 'iso' })
 194         or output_pref({ dt => dt_from_string, dateonly => 1, dateformat => 'iso' });
 195
 196     $expdate = output_pref({ str => $expdate, dateonly => 1, dateformat => 'iso' });
 197
 198     # if we have an item selectionned, and the pickup branch is the same as the holdingbranch
 199     # of the document, we force the value $priority and $found .
 200     if ( $checkitem and not C4::Context->preference('ReservesNeedReturns') ) {
 201         my $item = Koha::Items->find( $checkitem ); # FIXME Prevent bad calls
 202
 203         if (
 204             # If item is already checked out, it cannot be set waiting
 205             !$item->onloan
 206
 207             # The item can't be waiting if it needs a transfer
 208             && $item->holdingbranch eq $branch
 209
 210             # Similarly, if in transit it can't be waiting
 211             && !$item->get_transfer
 212
 213             # If we can't hold damaged items, and it is damaged, it can't be waiting
 214             && ( $item->damaged && C4::Context->preference('AllowHoldsOnDamagedItems') || !$item->damaged )
 215
 216             # Lastly, if this already has holds, we shouldn't make it waiting for the new hold
 217             && !$item->current_holds->count )
 218         {
 219             $priority = 0;
 220             $found = 'W';
 221         }
 222     }
 223
 224     if ( C4::Context->preference('AllowHoldDateInFuture') ) {
 225
 226         # Make room in reserves for this before those of a later reserve date
 227         $priority = _ShiftPriorityByDateAndPriority( $biblionumber, $resdate, $priority );
 228     }
 229
 230     my $waitingdate;
 231
 232     # If the reserv had the waiting status, we had the value of the resdate
 233     if ( $found && $found eq 'W' ) {
 234         $waitingdate = $resdate;
 235     }
 236
 237     # Don't add itemtype limit if specific item is selected
 238     $itemtype = undef if $checkitem;
 239
 240     # updates take place here
 241     my $hold = Koha::Hold->new(
 242         {
 243             borrowernumber => $borrowernumber,
 244             biblionumber   => $biblionumber,
 245             reservedate    => $resdate,
 246             branchcode     => $branch,
 247             priority       => $priority,
 248             reservenotes   => $notes,
 249             itemnumber     => $checkitem,
 250             found          => $found,
 251             waitingdate    => $waitingdate,
 252             expirationdate => $expdate,
 253             itemtype       => $itemtype,
 254             item_level_hold => $checkitem ? 1 : 0,
 255             non_priority   => $non_priority ? 1 : 0,
 256         }
 257     )->store();
 258     $hold->set_waiting() if $found && $found eq 'W';
 259
 260     logaction( 'HOLDS', 'CREATE', $hold->id, Dumper($hold->unblessed) )
 261         if C4::Context->preference('HoldsLog');
 262
 263     my $reserve_id = $hold->id();
 264
 265     # add a reserve fee if needed
 266     if ( C4::Context->preference('HoldFeeMode') ne 'any_time_is_collected' ) {
 267         my $reserve_fee = GetReserveFee( $borrowernumber, $biblionumber );
 268         ChargeReserveFee( $borrowernumber, $reserve_fee, $title );
 269     }
 270
 271     _FixPriority({ biblionumber => $biblionumber});
 272
 273     # Send e-mail to librarian if syspref is active
 274     if(C4::Context->preference("emailLibrarianWhenHoldIsPlaced")){
 275         my $patron = Koha::Patrons->find( $borrowernumber );
 276         my $library = $patron->library;
 277         if ( my $letter =  C4::Letters::GetPreparedLetter (
 278             module => 'reserves',
 279             letter_code => 'HOLDPLACED',
 280             branchcode => $branch,
 281             lang => $patron->lang,
 282             tables => {
 283                 'branches'    => $library->unblessed,
 284                 'borrowers'   => $patron->unblessed,
 285                 'biblio'      => $biblionumber,
 286                 'biblioitems' => $biblionumber,
 287                 'items'       => $checkitem,
 288                 'reserves'    => $hold->unblessed,
 289             },
 290         ) ) {
 291
 292             my $branch_email_address = $library->inbound_email_address;
 293
 294             C4::Letters::EnqueueLetter(
 295                 {
 296                     letter                 => $letter,
 297                     borrowernumber         => $borrowernumber,
 298                     message_transport_type => 'email',
 299                     to_address             => $branch_email_address,
 300                 }
 301             );
 302         }
 303     }
 304
 305     Koha::Plugins->call('after_hold_create', $hold);
 306
 307     return $reserve_id;
 308 }
 309
 310 =head2 CanBookBeReserved
 311
 312   $canReserve = &CanBookBeReserved($borrowernumber, $biblionumber, $branchcode, $params)
 313   if ($canReserve eq 'OK') { #We can reserve this Item! }
 314
 315   $params are passed directly through to CanItemBeReserved
 316
 317 See CanItemBeReserved() for possible return values.
 318
 319 =cut
 320
 321 sub CanBookBeReserved{
 322     my ($borrowernumber, $biblionumber, $pickup_branchcode, $params) = @_;
 323
 324     # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
 325     if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
 326         && C4::Circulation::CheckIfIssuedToPatron( $borrowernumber, $biblionumber ) ) {
 327         return { status =>'alreadypossession' };
 328     }
 329
 330     my @itemnumbers = Koha::Items->search({ biblionumber => $biblionumber})->get_column("itemnumber");
 331     #get items linked via host records
 332     my @hostitems = get_hostitemnumbers_of($biblionumber);
 333     if (@hostitems){
 334         push (@itemnumbers, @hostitems);
 335     }
 336
 337     my $canReserve = { status => '' };
 338     foreach my $itemnumber (@itemnumbers) {
 339         $canReserve = CanItemBeReserved( $borrowernumber, $itemnumber, $pickup_branchcode, $params );
 340         return { status => 'OK' } if $canReserve->{status} eq 'OK';
 341     }
 342     return $canReserve;
 343 }
 344
 345 =head2 CanItemBeReserved
 346
 347   $canReserve = &CanItemBeReserved($borrowernumber, $itemnumber, $branchcode, $params)
 348   if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }
 349
 350   current params are:
 351   'ignore_found_holds' - if true holds that have been trapped are not counted
 352   toward the patron limit, used by checkHighHolds to avoid counting the hold we will fill with the
 353   current checkout against the high holds threshold
 354   'ignore_hold_counts' - we use this routine to check if an item can fill a hold - on this case we
 355   should not check if there are too many holds as we only csre about reservability
 356
 357 @RETURNS { status => OK },              if the Item can be reserved.
 358          { status => ageRestricted },   if the Item is age restricted for this borrower.
 359          { status => damaged },         if the Item is damaged.
 360          { status => cannotReserveFromOtherBranches }, if syspref 'canreservefromotherbranches' is OK.
 361          { status => branchNotInHoldGroup }, if borrower home library is not in hold group, and holds are only allowed from hold groups.
 362          { status => tooManyReserves, limit => $limit }, if the borrower has exceeded their maximum reserve amount.
 363          { status => notReservable },   if holds on this item are not allowed
 364          { status => libraryNotFound },   if given branchcode is not an existing library
 365          { status => libraryNotPickupLocation },   if given branchcode is not configured to be a pickup location
 366          { status => cannotBeTransferred }, if branch transfer limit applies on given item and branchcode
 367          { status => pickupNotInHoldGroup }, pickup location is not in hold group, and pickup locations are only allowed from hold groups.
 368
 369 =cut
 370
 371 sub CanItemBeReserved {
 372     my ( $borrowernumber, $itemnumber, $pickup_branchcode, $params ) = @_;
 373
 374     my $dbh = C4::Context->dbh;
 375     my $ruleitemtype;    # itemtype of the matching issuing rule
 376     my $allowedreserves  = 0; # Total number of holds allowed across all records, default to none
 377
 378     # we retrieve borrowers and items informations #
 379     # item->{itype} will come for biblioitems if necessery
 380     my $item       = Koha::Items->find($itemnumber);
 381     my $biblio     = $item->biblio;
 382     my $patron = Koha::Patrons->find( $borrowernumber );
 383     my $borrower = $patron->unblessed;
 384
 385     # If an item is damaged and we don't allow holds on damaged items, we can stop right here
 386     return { status =>'damaged' }
 387       if ( $item->damaged
 388         && !C4::Context->preference('AllowHoldsOnDamagedItems') );
 389
 390     # Check for the age restriction
 391     my ( $ageRestriction, $daysToAgeRestriction ) =
 392       C4::Circulation::GetAgeRestriction( $biblio->biblioitem->agerestriction, $borrower );
 393     return { status => 'ageRestricted' } if $daysToAgeRestriction && $daysToAgeRestriction > 0;
 394
 395     # Check that the patron doesn't have an item level hold on this item already
 396     return { status =>'itemAlreadyOnHold' }
 397       if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $borrowernumber, itemnumber => $itemnumber } )->count() );
 398
 399     # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
 400     if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
 401         && C4::Circulation::CheckIfIssuedToPatron( $patron->borrowernumber, $biblio->biblionumber ) ) {
 402         return { status =>'alreadypossession' };
 403     }
 404
 405     my $controlbranch = C4::Context->preference('ReservesControlBranch');
 406
 407     my $querycount = q{
 408         SELECT count(*) AS count
 409           FROM reserves
 410      LEFT JOIN items USING (itemnumber)
 411      LEFT JOIN biblioitems ON (reserves.biblionumber=biblioitems.biblionumber)
 412      LEFT JOIN borrowers USING (borrowernumber)
 413          WHERE borrowernumber = ?
 414     };
 415
 416     my $branchcode  = "";
 417     my $branchfield = "reserves.branchcode";
 418
 419     if ( $controlbranch eq "ItemHomeLibrary" ) {
 420         $branchfield = "items.homebranch";
 421         $branchcode  = $item->homebranch;
 422     }
 423     elsif ( $controlbranch eq "PatronLibrary" ) {
 424         $branchfield = "borrowers.branchcode";
 425         $branchcode  = $borrower->{branchcode};
 426     }
 427
 428     # we retrieve rights
 429     if (
 430         my $reservesallowed = Koha::CirculationRules->get_effective_rule({
 431                 itemtype     => $item->effective_itemtype,
 432                 categorycode => $borrower->{categorycode},
 433                 branchcode   => $branchcode,
 434                 rule_name    => 'reservesallowed',
 435         })
 436     ) {
 437         $ruleitemtype     = $reservesallowed->itemtype;
 438         $allowedreserves  = $reservesallowed->rule_value // 0; #undefined is 0, blank is unlimited
 439     }
 440     else {
 441         $ruleitemtype = undef;
 442     }
 443
 444     my $rights = Koha::CirculationRules->get_effective_rules({
 445         categorycode => $borrower->{'categorycode'},
 446         itemtype     => $item->effective_itemtype,
 447         branchcode   => $branchcode,
 448         rules        => ['holds_per_record','holds_per_day']
 449     });
 450     my $holds_per_record = $rights->{holds_per_record} // 1;
 451     my $holds_per_day    = $rights->{holds_per_day};
 452
 453     my $search_params = {
 454         borrowernumber => $borrowernumber,
 455         biblionumber   => $item->biblionumber,
 456     };
 457     $search_params->{found} = undef if $params->{ignore_found_holds};
 458
 459     my $holds = Koha::Holds->search($search_params);
 460     if (!$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} eq 'not_allowed' ) {
 532         return { status => 'notReservable' };
 533     }
 534
 535     if (   $branchitemrule->{holdallowed} eq 'from_home_library'
 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} eq 'from_local_hold_group') {
 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'} eq 'not_allowed');
 897                     next if (($branchitemrule->{'holdallowed'} eq 'from_home_library') && ($branch ne $patron->branchcode));
 898                     my $library = Koha::Libraries->find({branchcode=>$item->homebranch});
 899                     next if (($branchitemrule->{'holdallowed'} eq 'from_local_hold_group') && (!$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         # Complete transfer if one exists
1207         my $transfer = $hold->item->get_transfer;
1208         $transfer->receive if $transfer;
1209     }
1210
1211     _FixPriority( { biblionumber => $biblionumber } );
1212     my $item = Koha::Items->find($itemnumber);
1213     if ( $item->location && $item->location eq 'CART'
1214         && ( !$item->permanent_location || $item->permanent_location ne 'CART' ) ) {
1215       CartToShelf( $itemnumber );
1216     }
1217
1218     my $std = $dbh->prepare(q{
1219         DELETE  q, t
1220         FROM    tmp_holdsqueue q
1221         INNER JOIN hold_fill_targets t
1222         ON  q.borrowernumber = t.borrowernumber
1223             AND q.biblionumber = t.biblionumber
1224             AND q.itemnumber = t.itemnumber
1225             AND q.item_level_request = t.item_level_request
1226             AND q.holdingbranch = t.source_branchcode
1227         WHERE t.reserve_id = ?
1228     });
1229     $std->execute($hold->reserve_id);
1230
1231     logaction( 'HOLDS', 'MODIFY', $hold->reserve_id, Dumper($hold->get_from_storage->unblessed) )
1232         if C4::Context->preference('HoldsLog');
1233
1234     return;
1235 }
1236
1237 =head2 ModReserveCancelAll
1238
1239   ($messages,$nextreservinfo) = &ModReserveCancelAll($itemnumber,$borrowernumber,$reason);
1240
1241 function to cancel reserv,check other reserves, and transfer document if it's necessary
1242
1243 =cut
1244
1245 sub ModReserveCancelAll {
1246     my $messages;
1247     my $nextreservinfo;
1248     my ( $itemnumber, $borrowernumber, $cancellation_reason ) = @_;
1249
1250     #step 1 : cancel the reservation
1251     my $holds = Koha::Holds->search({ itemnumber => $itemnumber, borrowernumber => $borrowernumber });
1252     return unless $holds->count;
1253     $holds->next->cancel({ cancellation_reason => $cancellation_reason });
1254
1255     #step 2 launch the subroutine of the others reserves
1256     ( $messages, $nextreservinfo ) = GetOtherReserves($itemnumber);
1257
1258     return ( $messages, $nextreservinfo->{borrowernumber} );
1259 }
1260
1261 =head2 ModReserveMinusPriority
1262
1263   &ModReserveMinusPriority($itemnumber,$borrowernumber,$biblionumber)
1264
1265 Reduce the values of queued list
1266
1267 =cut
1268
1269 sub ModReserveMinusPriority {
1270     my ( $itemnumber, $reserve_id ) = @_;
1271
1272     #first step update the value of the first person on reserv
1273     my $dbh   = C4::Context->dbh;
1274     my $query = "
1275         UPDATE reserves
1276         SET    priority = 0 , itemnumber = ?
1277         WHERE  reserve_id = ?
1278     ";
1279     my $sth_upd = $dbh->prepare($query);
1280     $sth_upd->execute( $itemnumber, $reserve_id );
1281     # second step update all others reserves
1282     _FixPriority({ reserve_id => $reserve_id, rank => '0' });
1283 }
1284
1285 =head2 IsAvailableForItemLevelRequest
1286
1287   my $is_available = IsAvailableForItemLevelRequest( $item_record, $borrower_record, $pickup_branchcode );
1288
1289 Checks whether a given item record is available for an
1290 item-level hold request.  An item is available if
1291
1292 * it is not lost AND
1293 * it is not damaged AND
1294 * it is not withdrawn AND
1295 * a waiting or in transit reserve is placed on
1296 * does not have a not for loan value > 0
1297
1298 Need to check the issuingrules onshelfholds column,
1299 if this is set items on the shelf can be placed on hold
1300
1301 Note that IsAvailableForItemLevelRequest() does not
1302 check if the staff operator is authorized to place
1303 a request on the item - in particular,
1304 this routine does not check IndependentBranches
1305 and canreservefromotherbranches.
1306
1307 Note also that this subroutine does not checks smart
1308 rules limits for item by reservesallowed/holds_per_record
1309 values, this complemented in calling code with calls and
1310 checks with CanItemBeReserved or CanBookBeReserved.
1311
1312 =cut
1313
1314 sub IsAvailableForItemLevelRequest {
1315     my $item                = shift;
1316     my $patron              = shift;
1317     my $pickup_branchcode   = shift;
1318     # items_any_available is precalculated status passed from request.pl when set of items
1319     # looped outside of IsAvailableForItemLevelRequest to avoid nested loops:
1320     my $items_any_available = shift;
1321
1322     my $dbh = C4::Context->dbh;
1323     # must check the notforloan setting of the itemtype
1324     # FIXME - a lot of places in the code do this
1325     #         or something similar - need to be
1326     #         consolidated
1327     my $itemtype = $item->effective_itemtype;
1328     my $notforloan_per_itemtype = Koha::ItemTypes->find($itemtype)->notforloan;
1329
1330     return 0 if
1331         $notforloan_per_itemtype ||
1332         $item->itemlost        ||
1333         $item->notforloan > 0  || # item with negative or zero notforloan value is holdable
1334         $item->withdrawn        ||
1335         ($item->damaged && !C4::Context->preference('AllowHoldsOnDamagedItems'));
1336
1337     if ($pickup_branchcode) {
1338         my $destination = Koha::Libraries->find($pickup_branchcode);
1339         return 0 unless $destination;
1340         return 0 unless $destination->pickup_location;
1341         return 0 unless $item->can_be_transferred( { to => $destination } );
1342         my $reserves_control_branch =
1343             GetReservesControlBranch( $item->unblessed(), $patron->unblessed() );
1344         my $branchitemrule =
1345             C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->itype );
1346         my $home_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
1347         return 0 unless $branchitemrule->{hold_fulfillment_policy} ne 'holdgroup' || $home_library->validate_hold_sibling( {branchcode => $pickup_branchcode} );
1348     }
1349
1350     my $on_shelf_holds = Koha::CirculationRules->get_onshelfholds_policy( { item => $item, patron => $patron } );
1351
1352     if ( $on_shelf_holds == 1 ) {
1353         return 1;
1354     } elsif ( $on_shelf_holds == 2 ) {
1355
1356         # if we have this param predefined from outer caller sub, we just need
1357         # to return it, so we saving from having loop inside other loop:
1358         return  $items_any_available ? 0 : 1
1359             if defined $items_any_available;
1360
1361         my $any_available = ItemsAnyAvailableAndNotRestricted( { biblionumber => $item->biblionumber, patron => $patron });
1362         return $any_available ? 0 : 1;
1363     } else { # on_shelf_holds == 0 "If any unavailable" (the description is rather cryptic and could still be improved)
1364         return $item->onloan || IsItemOnHoldAndFound( $item->itemnumber );
1365     }
1366 }
1367
1368 =head2 ItemsAnyAvailableAndNotRestricted
1369
1370   ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron });
1371
1372 This function checks all items for specified biblionumber (numeric) against patron (object)
1373 and returns true (1) if at least one item available for loan/check out/present/not held
1374 and also checks other parameters logic which not restricts item for hold at all (for ex.
1375 AllowHoldsOnDamagedItems or 'holdallowed' own/sibling library)
1376
1377 =cut
1378
1379 sub ItemsAnyAvailableAndNotRestricted {
1380     my $param = shift;
1381
1382     my @items = Koha::Items->search( { biblionumber => $param->{biblionumber} } );
1383
1384     foreach my $i (@items) {
1385         my $reserves_control_branch =
1386             GetReservesControlBranch( $i->unblessed(), $param->{patron}->unblessed );
1387         my $branchitemrule =
1388             C4::Circulation::GetBranchItemRule( $reserves_control_branch, $i->itype );
1389         my $item_library = Koha::Libraries->find( { branchcode => $i->homebranch } );
1390
1391         # we can return (end the loop) when first one found:
1392         return 1
1393             unless $i->itemlost
1394             || $i->notforloan # items with non-zero notforloan cannot be checked out
1395             || $i->withdrawn
1396             || $i->onloan
1397             || IsItemOnHoldAndFound( $i->id )
1398             || ( $i->damaged
1399                  && ! C4::Context->preference('AllowHoldsOnDamagedItems') )
1400             || Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
1401             || $branchitemrule->{holdallowed} eq 'from_home_library' && $param->{patron}->branchcode ne $i->homebranch
1402             || $branchitemrule->{holdallowed} eq 'from_local_hold_group' && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } )
1403             || CanItemBeReserved( $param->{patron}->borrowernumber, $i->id )->{status} ne 'OK';
1404     }
1405
1406     return 0;
1407 }
1408
1409 =head2 AlterPriority
1410
1411   AlterPriority( $where, $reserve_id, $prev_priority, $next_priority, $first_priority, $last_priority );
1412
1413 This function changes a reserve's priority up, down, to the top, or to the bottom.
1414 Input: $where is 'up', 'down', 'top' or 'bottom'. Biblionumber, Date reserve was placed
1415
1416 =cut
1417
1418 sub AlterPriority {
1419     my ( $where, $reserve_id, $prev_priority, $next_priority, $first_priority, $last_priority ) = @_;
1420
1421     my $hold = Koha::Holds->find( $reserve_id );
1422     return unless $hold;
1423
1424     if ( $hold->cancellationdate ) {
1425         warn "I cannot alter the priority for reserve_id $reserve_id, the reserve has been cancelled (" . $hold->cancellationdate . ')';
1426         return;
1427     }
1428
1429     if ( $where eq 'up' ) {
1430       return unless $prev_priority;
1431       _FixPriority({ reserve_id => $reserve_id, rank => $prev_priority })
1432     } elsif ( $where eq 'down' ) {
1433       return unless $next_priority;
1434       _FixPriority({ reserve_id => $reserve_id, rank => $next_priority })
1435     } elsif ( $where eq 'top' ) {
1436       _FixPriority({ reserve_id => $reserve_id, rank => $first_priority })
1437     } elsif ( $where eq 'bottom' ) {
1438       _FixPriority({ reserve_id => $reserve_id, rank => $last_priority });
1439     }
1440
1441     # FIXME Should return the new priority
1442 }
1443
1444 =head2 ToggleLowestPriority
1445
1446   ToggleLowestPriority( $borrowernumber, $biblionumber );
1447
1448 This function sets the lowestPriority field to true if is false, and false if it is true.
1449
1450 =cut
1451
1452 sub ToggleLowestPriority {
1453     my ( $reserve_id ) = @_;
1454
1455     my $dbh = C4::Context->dbh;
1456
1457     my $sth = $dbh->prepare( "UPDATE reserves SET lowestPriority = NOT lowestPriority WHERE reserve_id = ?");
1458     $sth->execute( $reserve_id );
1459
1460     _FixPriority({ reserve_id => $reserve_id, rank => '999999' });
1461 }
1462
1463 =head2 ToggleSuspend
1464
1465   ToggleSuspend( $reserve_id );
1466
1467 This function sets the suspend field to true if is false, and false if it is true.
1468 If the reserve is currently suspended with a suspend_until date, that date will
1469 be cleared when it is unsuspended.
1470
1471 =cut
1472
1473 sub ToggleSuspend {
1474     my ( $reserve_id, $suspend_until ) = @_;
1475
1476     $suspend_until = dt_from_string($suspend_until) if ($suspend_until);
1477
1478     my $hold = Koha::Holds->find( $reserve_id );
1479
1480     if ( $hold->is_suspended ) {
1481         $hold->resume()
1482     } else {
1483         $hold->suspend_hold( $suspend_until );
1484     }
1485 }
1486
1487 =head2 SuspendAll
1488
1489   SuspendAll(
1490       borrowernumber   => $borrowernumber,
1491       [ biblionumber   => $biblionumber, ]
1492       [ suspend_until  => $suspend_until, ]
1493       [ suspend        => $suspend ]
1494   );
1495
1496   This function accepts a set of hash keys as its parameters.
1497   It requires either borrowernumber or biblionumber, or both.
1498
1499   suspend_until is wholly optional.
1500
1501 =cut
1502
1503 sub SuspendAll {
1504     my %params = @_;
1505
1506     my $borrowernumber = $params{'borrowernumber'} || undef;
1507     my $biblionumber   = $params{'biblionumber'}   || undef;
1508     my $suspend_until  = $params{'suspend_until'}  || undef;
1509     my $suspend = defined( $params{'suspend'} ) ? $params{'suspend'} : 1;
1510
1511     $suspend_until = eval { dt_from_string($suspend_until) }
1512       if ( defined($suspend_until) );
1513
1514     return unless ( $borrowernumber || $biblionumber );
1515
1516     my $params;
1517     $params->{found}          = undef;
1518     $params->{borrowernumber} = $borrowernumber if $borrowernumber;
1519     $params->{biblionumber}   = $biblionumber if $biblionumber;
1520
1521     my @holds = Koha::Holds->search($params);
1522
1523     if ($suspend) {
1524         map { $_->suspend_hold($suspend_until) } @holds;
1525     }
1526     else {
1527         map { $_->resume() } @holds;
1528     }
1529 }
1530
1531
1532 =head2 _FixPriority
1533
1534   _FixPriority({
1535     reserve_id => $reserve_id,
1536     [rank => $rank,]
1537     [ignoreSetLowestRank => $ignoreSetLowestRank]
1538   });
1539
1540   or
1541
1542   _FixPriority({ biblionumber => $biblionumber});
1543
1544 This routine adjusts the priority of a hold request and holds
1545 on the same bib.
1546
1547 In the first form, where a reserve_id is passed, the priority of the
1548 hold is set to supplied rank, and other holds for that bib are adjusted
1549 accordingly.  If the rank is "del", the hold is cancelled.  If no rank
1550 is supplied, all of the holds on that bib have their priority adjusted
1551 as if the second form had been used.
1552
1553 In the second form, where a biblionumber is passed, the holds on that
1554 bib (that are not captured) are sorted in order of increasing priority,
1555 then have reserves.priority set so that the first non-captured hold
1556 has its priority set to 1, the second non-captured hold has its priority
1557 set to 2, and so forth.
1558
1559 In both cases, holds that have the lowestPriority flag on are have their
1560 priority adjusted to ensure that they remain at the end of the line.
1561
1562 Note that the ignoreSetLowestRank parameter is meant to be used only
1563 when _FixPriority calls itself.
1564
1565 =cut
1566
1567 sub _FixPriority {
1568     my ( $params ) = @_;
1569     my $reserve_id = $params->{reserve_id};
1570     my $rank = $params->{rank} // '';
1571     my $ignoreSetLowestRank = $params->{ignoreSetLowestRank};
1572     my $biblionumber = $params->{biblionumber};
1573
1574     my $dbh = C4::Context->dbh;
1575
1576     my $hold;
1577     if ( $reserve_id ) {
1578         $hold = Koha::Holds->find( $reserve_id );
1579         if (!defined $hold){
1580             # may have already been checked out and hold fulfilled
1581             $hold = Koha::Old::Holds->find( $reserve_id );
1582         }
1583         return unless $hold;
1584     }
1585
1586     unless ( $biblionumber ) { # FIXME This is a very weird API
1587         $biblionumber = $hold->biblionumber;
1588     }
1589
1590     if ( $rank eq "del" ) { # FIXME will crash if called without $hold
1591         $hold->cancel;
1592     }
1593     elsif ( $reserve_id && ( $rank eq "W" || $rank eq "0" ) ) {
1594
1595         # make sure priority for waiting or in-transit items is 0
1596         my $query = "
1597             UPDATE reserves
1598             SET    priority = 0
1599             WHERE reserve_id = ?
1600             AND found IN ('W', 'T', 'P')
1601         ";
1602         my $sth = $dbh->prepare($query);
1603         $sth->execute( $reserve_id );
1604     }
1605     my @priority;
1606
1607     # get whats left
1608     my $query = "
1609         SELECT reserve_id, borrowernumber, reservedate
1610         FROM   reserves
1611         WHERE  biblionumber   = ?
1612           AND  ((found <> 'W' AND found <> 'T' AND found <> 'P') OR found IS NULL)
1613         ORDER BY priority ASC
1614     ";
1615     my $sth = $dbh->prepare($query);
1616     $sth->execute( $biblionumber );
1617     while ( my $line = $sth->fetchrow_hashref ) {
1618         push( @priority,     $line );
1619     }
1620
1621     # FIXME This whole sub must be rewritten, especially to highlight what is done when reserve_id is not given
1622     # To find the matching index
1623     my $i;
1624     my $key = -1;    # to allow for 0 to be a valid result
1625     for ( $i = 0 ; $i < @priority ; $i++ ) {
1626         if ( $reserve_id && $reserve_id == $priority[$i]->{'reserve_id'} ) {
1627             $key = $i;    # save the index
1628             last;
1629         }
1630     }
1631
1632     # if index exists in array then move it to new position
1633     if ( $key > -1 && $rank ne 'del' && $rank > 0 ) {
1634         my $new_rank = $rank -
1635           1;    # $new_rank is what you want the new index to be in the array
1636         my $moving_item = splice( @priority, $key, 1 );
1637         splice( @priority, $new_rank, 0, $moving_item );
1638     }
1639
1640     # now fix the priority on those that are left....
1641     $query = "
1642         UPDATE reserves
1643         SET    priority = ?
1644         WHERE  reserve_id = ?
1645     ";
1646     $sth = $dbh->prepare($query);
1647     for ( my $j = 0 ; $j < @priority ; $j++ ) {
1648         $sth->execute(
1649             $j + 1,
1650             $priority[$j]->{'reserve_id'}
1651         );
1652     }
1653
1654     $sth = $dbh->prepare( "SELECT reserve_id FROM reserves WHERE lowestPriority = 1 ORDER BY priority" );
1655     $sth->execute();
1656
1657     unless ( $ignoreSetLowestRank ) {
1658       while ( my $res = $sth->fetchrow_hashref() ) {
1659         _FixPriority({
1660             reserve_id => $res->{'reserve_id'},
1661             rank => '999999',
1662             ignoreSetLowestRank => 1
1663         });
1664       }
1665     }
1666 }
1667
1668 =head2 _Findgroupreserve
1669
1670   @results = &_Findgroupreserve($biblioitemnumber, $biblionumber, $itemnumber, $lookahead, $ignore_borrowers);
1671
1672 Looks for a holds-queue based item-specific match first, then for a holds-queue title-level match, returning the
1673 first match found.  If neither, then we look for non-holds-queue based holds.
1674 Lookahead is the number of days to look in advance.
1675
1676 C<&_Findgroupreserve> returns :
1677 C<@results> is an array of references-to-hash whose keys are mostly
1678 fields from the reserves table of the Koha database, plus
1679 C<biblioitemnumber>.
1680
1681 This routine with either return:
1682 1 - Item specific holds from the holds queue
1683 2 - Title level holds from the holds queue
1684 3 - All holds for this biblionumber
1685
1686 All return values will respect any borrowernumbers passed as arrayref in $ignore_borrowers
1687
1688 =cut
1689
1690 sub _Findgroupreserve {
1691     my ( $bibitem, $biblio, $itemnumber, $lookahead, $ignore_borrowers) = @_;
1692     my $dbh   = C4::Context->dbh;
1693
1694     # TODO: consolidate at least the SELECT portion of the first 2 queries to a common $select var.
1695     # check for exact targeted match
1696     my $item_level_target_query = qq{
1697         SELECT reserves.biblionumber        AS biblionumber,
1698                reserves.borrowernumber      AS borrowernumber,
1699                reserves.reservedate         AS reservedate,
1700                reserves.branchcode          AS branchcode,
1701                reserves.cancellationdate    AS cancellationdate,
1702                reserves.found               AS found,
1703                reserves.reservenotes        AS reservenotes,
1704                reserves.priority            AS priority,
1705                reserves.timestamp           AS timestamp,
1706                biblioitems.biblioitemnumber AS biblioitemnumber,
1707                reserves.itemnumber          AS itemnumber,
1708                reserves.reserve_id          AS reserve_id,
1709                reserves.itemtype            AS itemtype,
1710                reserves.non_priority        AS non_priority
1711         FROM reserves
1712         JOIN biblioitems USING (biblionumber)
1713         JOIN hold_fill_targets USING (reserve_id)
1714         WHERE found IS NULL
1715         AND priority > 0
1716         AND item_level_request = 1
1717         AND hold_fill_targets.itemnumber = ?
1718         AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1719         AND suspend = 0
1720         ORDER BY priority
1721     };
1722     my $sth = $dbh->prepare($item_level_target_query);
1723     $sth->execute($itemnumber, $lookahead||0);
1724     my @results;
1725     if ( my $data = $sth->fetchrow_hashref ) {
1726         push( @results, $data )
1727           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1728     }
1729     return @results if @results;
1730
1731     # check for title-level targeted match
1732     my $title_level_target_query = qq{
1733         SELECT reserves.biblionumber        AS biblionumber,
1734                reserves.borrowernumber      AS borrowernumber,
1735                reserves.reservedate         AS reservedate,
1736                reserves.branchcode          AS branchcode,
1737                reserves.cancellationdate    AS cancellationdate,
1738                reserves.found               AS found,
1739                reserves.reservenotes        AS reservenotes,
1740                reserves.priority            AS priority,
1741                reserves.timestamp           AS timestamp,
1742                biblioitems.biblioitemnumber AS biblioitemnumber,
1743                reserves.itemnumber          AS itemnumber,
1744                reserves.reserve_id          AS reserve_id,
1745                reserves.itemtype            AS itemtype,
1746                reserves.non_priority        AS non_priority
1747         FROM reserves
1748         JOIN biblioitems USING (biblionumber)
1749         JOIN hold_fill_targets USING (reserve_id)
1750         WHERE found IS NULL
1751         AND priority > 0
1752         AND item_level_request = 0
1753         AND hold_fill_targets.itemnumber = ?
1754         AND reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1755         AND suspend = 0
1756         ORDER BY priority
1757     };
1758     $sth = $dbh->prepare($title_level_target_query);
1759     $sth->execute($itemnumber, $lookahead||0);
1760     @results = ();
1761     if ( my $data = $sth->fetchrow_hashref ) {
1762         push( @results, $data )
1763           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1764     }
1765     return @results if @results;
1766
1767     my $query = qq{
1768         SELECT reserves.biblionumber               AS biblionumber,
1769                reserves.borrowernumber             AS borrowernumber,
1770                reserves.reservedate                AS reservedate,
1771                reserves.waitingdate                AS waitingdate,
1772                reserves.branchcode                 AS branchcode,
1773                reserves.cancellationdate           AS cancellationdate,
1774                reserves.found                      AS found,
1775                reserves.reservenotes               AS reservenotes,
1776                reserves.priority                   AS priority,
1777                reserves.timestamp                  AS timestamp,
1778                reserves.itemnumber                 AS itemnumber,
1779                reserves.reserve_id                 AS reserve_id,
1780                reserves.itemtype                   AS itemtype,
1781                reserves.non_priority        AS non_priority
1782         FROM reserves
1783         WHERE reserves.biblionumber = ?
1784           AND (reserves.itemnumber IS NULL OR reserves.itemnumber = ?)
1785           AND reserves.reservedate <= DATE_ADD(NOW(),INTERVAL ? DAY)
1786           AND suspend = 0
1787           ORDER BY priority
1788     };
1789     $sth = $dbh->prepare($query);
1790     $sth->execute( $biblio, $itemnumber, $lookahead||0);
1791     @results = ();
1792     while ( my $data = $sth->fetchrow_hashref ) {
1793         push( @results, $data )
1794           unless any{ $data->{borrowernumber} eq $_ } @$ignore_borrowers ;
1795     }
1796     return @results;
1797 }
1798
1799 =head2 _koha_notify_reserve
1800
1801   _koha_notify_reserve( $hold->reserve_id );
1802
1803 Sends a notification to the patron that their hold has been filled (through
1804 ModReserveAffect, _not_ ModReserveFill)
1805
1806 The letter code for this notice may be found using the following query:
1807
1808     select distinct letter_code
1809     from message_transports
1810     inner join message_attributes using (message_attribute_id)
1811     where message_name = 'Hold_Filled'
1812
1813 This will probably sipmly be 'HOLD', but because it is defined in the database,
1814 it is subject to addition or change.
1815
1816 The following tables are availalbe witin the notice:
1817
1818     branches
1819     borrowers
1820     biblio
1821     biblioitems
1822     reserves
1823     items
1824
1825 =cut
1826
1827 sub _koha_notify_reserve {
1828     my $reserve_id = shift;
1829     my $hold = Koha::Holds->find($reserve_id);
1830     my $borrowernumber = $hold->borrowernumber;
1831
1832     my $patron = Koha::Patrons->find( $borrowernumber );
1833
1834     # Try to get the borrower's email address
1835     my $to_address = $patron->notice_email_address;
1836
1837     my $messagingprefs = C4::Members::Messaging::GetMessagingPreferences( {
1838             borrowernumber => $borrowernumber,
1839             message_name => 'Hold_Filled'
1840     } );
1841
1842     my $library = Koha::Libraries->find( $hold->branchcode )->unblessed;
1843
1844     my $admin_email_address = $library->{branchemail} || C4::Context->preference('KohaAdminEmailAddress');
1845
1846     my %letter_params = (
1847         module => 'reserves',
1848         branchcode => $hold->branchcode,
1849         lang => $patron->lang,
1850         tables => {
1851             'branches'       => $library,
1852             'borrowers'      => $patron->unblessed,
1853             'biblio'         => $hold->biblionumber,
1854             'biblioitems'    => $hold->biblionumber,
1855             'reserves'       => $hold->unblessed,
1856             'items'          => $hold->itemnumber,
1857         },
1858     );
1859
1860     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.
1861     my $send_notification = sub {
1862         my ( $mtt, $letter_code ) = (@_);
1863         return unless defined $letter_code;
1864         $letter_params{letter_code} = $letter_code;
1865         $letter_params{message_transport_type} = $mtt;
1866         my $letter =  C4::Letters::GetPreparedLetter ( %letter_params );
1867         unless ($letter) {
1868             warn "Could not find a letter called '$letter_params{'letter_code'}' for $mtt in the 'reserves' module";
1869             return;
1870         }
1871
1872         C4::Letters::EnqueueLetter( {
1873             letter => $letter,
1874             borrowernumber => $borrowernumber,
1875             from_address => $admin_email_address,
1876             message_transport_type => $mtt,
1877         } );
1878     };
1879
1880     while ( my ( $mtt, $letter_code ) = each %{ $messagingprefs->{transports} } ) {
1881         next if (
1882                ( $mtt eq 'email' and not $to_address ) # No email address
1883             or ( $mtt eq 'sms'   and not $patron->smsalertnumber ) # No SMS number
1884             or ( $mtt eq 'itiva' and C4::Context->preference('TalkingTechItivaPhoneNotification') ) # Notice is handled by TalkingTech_itiva_outbound.pl
1885             or ( $mtt eq 'phone' and not $patron->phone ) # No phone number to call
1886         );
1887
1888         &$send_notification($mtt, $letter_code);
1889         $notification_sent++;
1890     }
1891     #Making sure that a print notification is sent if no other transport types can be utilized.
1892     if (! $notification_sent) {
1893         &$send_notification('print', 'HOLD');
1894     }
1895
1896 }
1897
1898 =head2 _ShiftPriorityByDateAndPriority
1899
1900   $new_priority = _ShiftPriorityByDateAndPriority( $biblionumber, $reservedate, $priority );
1901
1902 This increments the priority of all reserves after the one
1903 with either the lowest date after C<$reservedate>
1904 or the lowest priority after C<$priority>.
1905
1906 It effectively makes room for a new reserve to be inserted with a certain
1907 priority, which is returned.
1908
1909 This is most useful when the reservedate can be set by the user.  It allows
1910 the new reserve to be placed before other reserves that have a later
1911 reservedate.  Since priority also is set by the form in reserves/request.pl
1912 the sub accounts for that too.
1913
1914 =cut
1915
1916 sub _ShiftPriorityByDateAndPriority {
1917     my ( $biblio, $resdate, $new_priority ) = @_;
1918
1919     my $dbh = C4::Context->dbh;
1920     my $query = "SELECT priority FROM reserves WHERE biblionumber = ? AND ( reservedate > ? OR priority > ? ) ORDER BY priority ASC LIMIT 1";
1921     my $sth = $dbh->prepare( $query );
1922     $sth->execute( $biblio, $resdate, $new_priority );
1923     my $min_priority = $sth->fetchrow;
1924     # if no such matches are found, $new_priority remains as original value
1925     $new_priority = $min_priority if ( $min_priority );
1926
1927     # Shift the priority up by one; works in conjunction with the next SQL statement
1928     $query = "UPDATE reserves
1929               SET priority = priority+1
1930               WHERE biblionumber = ?
1931               AND borrowernumber = ?
1932               AND reservedate = ?
1933               AND found IS NULL";
1934     my $sth_update = $dbh->prepare( $query );
1935
1936     # Select all reserves for the biblio with priority greater than $new_priority, and order greatest to least
1937     $query = "SELECT borrowernumber, reservedate FROM reserves WHERE priority >= ? AND biblionumber = ? ORDER BY priority DESC";
1938     $sth = $dbh->prepare( $query );
1939     $sth->execute( $new_priority, $biblio );
1940     while ( my $row = $sth->fetchrow_hashref ) {
1941         $sth_update->execute( $biblio, $row->{borrowernumber}, $row->{reservedate} );
1942     }
1943
1944     return $new_priority;  # so the caller knows what priority they wind up receiving
1945 }
1946
1947 =head2 MoveReserve
1948
1949   MoveReserve( $itemnumber, $borrowernumber, $cancelreserve )
1950
1951 Use when checking out an item to handle reserves
1952 If $cancelreserve boolean is set to true, it will remove existing reserve
1953
1954 =cut
1955
1956 sub MoveReserve {
1957     my ( $itemnumber, $borrowernumber, $cancelreserve ) = @_;
1958
1959     $cancelreserve //= 0;
1960
1961     my $lookahead = C4::Context->preference('ConfirmFutureHolds'); #number of days to look for future holds
1962     my ( $restype, $res, undef ) = CheckReserves( $itemnumber, undef, $lookahead );
1963     return unless $res;
1964
1965     my $biblionumber     =  $res->{biblionumber};
1966
1967     if ($res->{borrowernumber} == $borrowernumber) {
1968         ModReserveFill($res);
1969     }
1970     else {
1971         # warn "Reserved";
1972         # The item is reserved by someone else.
1973         # Find this item in the reserves
1974
1975         my $borr_res  = Koha::Holds->search({
1976             borrowernumber => $borrowernumber,
1977             biblionumber   => $biblionumber,
1978         },{
1979             order_by       => 'priority'
1980         })->next();
1981
1982         if ( $borr_res ) {
1983             # The item is reserved by the current patron
1984             ModReserveFill($borr_res->unblessed);
1985         }
1986
1987         if ( $cancelreserve eq 'revert' ) { ## Revert waiting reserve to priority 1
1988             RevertWaitingStatus({ itemnumber => $itemnumber });
1989         }
1990         elsif ( $cancelreserve eq 'cancel' || $cancelreserve ) { # cancel reserves on this item
1991             my $hold = Koha::Holds->find( $res->{reserve_id} );
1992             $hold->cancel;
1993         }
1994     }
1995 }
1996
1997 =head2 MergeHolds
1998
1999   MergeHolds($dbh,$to_biblio, $from_biblio);
2000
2001 This shifts the holds from C<$from_biblio> to C<$to_biblio> and reorders them by the date they were placed
2002
2003 =cut
2004
2005 sub MergeHolds {
2006     my ( $dbh, $to_biblio, $from_biblio ) = @_;
2007     my $sth = $dbh->prepare(
2008         "SELECT count(*) as reserve_count FROM reserves WHERE biblionumber = ?"
2009     );
2010     $sth->execute($from_biblio);
2011     if ( my $data = $sth->fetchrow_hashref() ) {
2012
2013         # holds exist on old record, if not we don't need to do anything
2014         $sth = $dbh->prepare(
2015             "UPDATE reserves SET biblionumber = ? WHERE biblionumber = ?");
2016         $sth->execute( $to_biblio, $from_biblio );
2017
2018         # Reorder by date
2019         # don't reorder those already waiting
2020
2021         $sth = $dbh->prepare(
2022 "SELECT * FROM reserves WHERE biblionumber = ? AND (found NOT IN ('W', 'T', 'P') OR found is NULL) ORDER BY reservedate ASC"
2023         );
2024         my $upd_sth = $dbh->prepare(
2025 "UPDATE reserves SET priority = ? WHERE biblionumber = ? AND borrowernumber = ?
2026         AND reservedate = ? AND (itemnumber = ? or itemnumber is NULL) "
2027         );
2028         $sth->execute( $to_biblio );
2029         my $priority = 1;
2030         while ( my $reserve = $sth->fetchrow_hashref() ) {
2031             $upd_sth->execute(
2032                 $priority,                    $to_biblio,
2033                 $reserve->{'borrowernumber'}, $reserve->{'reservedate'},
2034                 $reserve->{'itemnumber'}
2035             );
2036             $priority++;
2037         }
2038     }
2039 }
2040
2041 =head2 RevertWaitingStatus
2042
2043   RevertWaitingStatus({ itemnumber => $itemnumber });
2044
2045   Reverts a 'waiting' hold back to a regular hold with a priority of 1.
2046
2047   Caveat: Any waiting hold fixed with RevertWaitingStatus will be an
2048           item level hold, even if it was only a bibliolevel hold to
2049           begin with. This is because we can no longer know if a hold
2050           was item-level or bib-level after a hold has been set to
2051           waiting status.
2052
2053 =cut
2054
2055 sub RevertWaitingStatus {
2056     my ( $params ) = @_;
2057     my $itemnumber = $params->{'itemnumber'};
2058
2059     return unless ( $itemnumber );
2060
2061     my $dbh = C4::Context->dbh;
2062
2063     ## Get the waiting reserve we want to revert
2064     my $hold = Koha::Holds->search(
2065         {
2066             itemnumber => $itemnumber,
2067             found => { not => undef },
2068         }
2069     )->next;
2070
2071     ## Increment the priority of all other non-waiting
2072     ## reserves for this bib record
2073     my $holds = Koha::Holds->search({ biblionumber => $hold->biblionumber, priority => { '>' => 0 } })
2074                            ->update({ priority => \'priority + 1' }, { no_triggers => 1 });
2075
2076     ## Fix up the currently waiting reserve
2077     $hold->set(
2078         {
2079             priority    => 1,
2080             found       => undef,
2081             waitingdate => undef,
2082             itemnumber  => $hold->item_level_hold ? $hold->itemnumber : undef,
2083         }
2084     )->store();
2085
2086     _FixPriority( { biblionumber => $hold->biblionumber } );
2087
2088     return $hold;
2089 }
2090
2091 =head2 ReserveSlip
2092
2093 ReserveSlip(
2094     {
2095         branchcode     => $branchcode,
2096         borrowernumber => $borrowernumber,
2097         biblionumber   => $biblionumber,
2098         [ itemnumber   => $itemnumber, ]
2099         [ barcode      => $barcode, ]
2100     }
2101   )
2102
2103 Returns letter hash ( see C4::Letters::GetPreparedLetter ) or undef
2104
2105 The letter code will be HOLD_SLIP, and the following tables are
2106 available within the slip:
2107
2108     reserves
2109     branches
2110     borrowers
2111     biblio
2112     biblioitems
2113     items
2114
2115 =cut
2116
2117 sub ReserveSlip {
2118     my ($args) = @_;
2119     my $branchcode     = $args->{branchcode};
2120     my $reserve_id = $args->{reserve_id};
2121
2122     my $hold = Koha::Holds->find($reserve_id);
2123     return unless $hold;
2124
2125     my $patron = $hold->borrower;
2126     my $reserve = $hold->unblessed;
2127
2128     return  C4::Letters::GetPreparedLetter (
2129         module => 'circulation',
2130         letter_code => 'HOLD_SLIP',
2131         branchcode => $branchcode,
2132         lang => $patron->lang,
2133         tables => {
2134             'reserves'    => $reserve,
2135             'branches'    => $reserve->{branchcode},
2136             'borrowers'   => $reserve->{borrowernumber},
2137             'biblio'      => $reserve->{biblionumber},
2138             'biblioitems' => $reserve->{biblionumber},
2139             'items'       => $reserve->{itemnumber},
2140         },
2141     );
2142 }
2143
2144 =head2 GetReservesControlBranch
2145
2146   my $reserves_control_branch = GetReservesControlBranch($item, $borrower);
2147
2148   Return the branchcode to be used to determine which reserves
2149   policy applies to a transaction.
2150
2151   C<$item> is a hashref for an item. Only 'homebranch' is used.
2152
2153   C<$borrower> is a hashref to borrower. Only 'branchcode' is used.
2154
2155 =cut
2156
2157 sub GetReservesControlBranch {
2158     my ( $item, $borrower ) = @_;
2159
2160     my $reserves_control = C4::Context->preference('ReservesControlBranch');
2161
2162     my $branchcode =
2163         ( $reserves_control eq 'ItemHomeLibrary' ) ? $item->{'homebranch'}
2164       : ( $reserves_control eq 'PatronLibrary' )   ? $borrower->{'branchcode'}
2165       :                                              undef;
2166
2167     return $branchcode;
2168 }
2169
2170 =head2 CalculatePriority
2171
2172     my $p = CalculatePriority($biblionumber, $resdate);
2173
2174 Calculate priority for a new reserve on biblionumber, placing it at
2175 the end of the line of all holds whose start date falls before
2176 the current system time and that are neither on the hold shelf
2177 or in transit.
2178
2179 The reserve date parameter is optional; if it is supplied, the
2180 priority is based on the set of holds whose start date falls before
2181 the parameter value.
2182
2183 After calculation of this priority, it is recommended to call
2184 _ShiftPriorityByDateAndPriority. Note that this is currently done in
2185 AddReserves.
2186
2187 =cut
2188
2189 sub CalculatePriority {
2190     my ( $biblionumber, $resdate ) = @_;
2191
2192     my $sql = q{
2193         SELECT COUNT(*) FROM reserves
2194         WHERE biblionumber = ?
2195         AND   priority > 0
2196         AND   (found IS NULL OR found = '')
2197     };
2198     #skip found==W or found==T or found==P (waiting, transit or processing holds)
2199     if( $resdate ) {
2200         $sql.= ' AND ( reservedate <= ? )';
2201     }
2202     else {
2203         $sql.= ' AND ( reservedate < NOW() )';
2204     }
2205     my $dbh = C4::Context->dbh();
2206     my @row = $dbh->selectrow_array(
2207         $sql,
2208         undef,
2209         $resdate ? ($biblionumber, $resdate) : ($biblionumber)
2210     );
2211
2212     return @row ? $row[0]+1 : 1;
2213 }
2214
2215 =head2 IsItemOnHoldAndFound
2216
2217     my $bool = IsItemFoundHold( $itemnumber );
2218
2219     Returns true if the item is currently on hold
2220     and that hold has a non-null found status ( W, T, etc. )
2221
2222 =cut
2223
2224 sub IsItemOnHoldAndFound {
2225     my ($itemnumber) = @_;
2226
2227     my $rs = Koha::Database->new()->schema()->resultset('Reserve');
2228
2229     my $found = $rs->count(
2230         {
2231             itemnumber => $itemnumber,
2232             found      => { '!=' => undef }
2233         }
2234     );
2235
2236     return $found;
2237 }
2238
2239 =head2 GetMaxPatronHoldsForRecord
2240
2241 my $holds_per_record = ReservesControlBranch( $borrowernumber, $biblionumber );
2242
2243 For multiple holds on a given record for a given patron, the max
2244 number of record level holds that a patron can be placed is the highest
2245 value of the holds_per_record rule for each item if the record for that
2246 patron. This subroutine finds and returns the highest holds_per_record
2247 rule value for a given patron id and record id.
2248
2249 =cut
2250
2251 sub GetMaxPatronHoldsForRecord {
2252     my ( $borrowernumber, $biblionumber ) = @_;
2253
2254     my $patron = Koha::Patrons->find($borrowernumber);
2255     my @items = Koha::Items->search( { biblionumber => $biblionumber } );
2256
2257     my $controlbranch = C4::Context->preference('ReservesControlBranch');
2258
2259     my $categorycode = $patron->categorycode;
2260     my $branchcode;
2261     $branchcode = $patron->branchcode if ( $controlbranch eq "PatronLibrary" );
2262
2263     my $max = 0;
2264     foreach my $item (@items) {
2265         my $itemtype = $item->effective_itemtype();
2266
2267         $branchcode = $item->homebranch if ( $controlbranch eq "ItemHomeLibrary" );
2268
2269         my $rule = Koha::CirculationRules->get_effective_rule({
2270             categorycode => $categorycode,
2271             itemtype     => $itemtype,
2272             branchcode   => $branchcode,
2273             rule_name    => 'holds_per_record'
2274         });
2275         my $holds_per_record = $rule ? $rule->rule_value : 0;
2276         $max = $holds_per_record if $holds_per_record > $max;
2277     }
2278
2279     return $max;
2280 }
2281
2282 =head1 AUTHOR
2283
2284 Koha Development Team <http://koha-community.org/>
2285
2286 =cut
2287
2288 1;