View | Details | Raw Unified | Return to bug 11999
Collapse All | Expand All

(-)a/C4/ILSDI/Services.pm (-4 / +5 lines)
Lines 488-494 sub GetServices { Link Here
488
488
489
    # Reserve level management
489
    # Reserve level management
490
    my $biblionumber = $item->{'biblionumber'};
490
    my $biblionumber = $item->{'biblionumber'};
491
    my $canbookbereserved = CanBookBeReserved( $borrower, $biblionumber );
491
    my ($canbookbereserved) = CanBookBeReserved( $borrowernumber, $biblionumber );
492
    if ($canbookbereserved) {
492
    if ($canbookbereserved) {
493
        push @availablefor, 'title level hold';
493
        push @availablefor, 'title level hold';
494
        my $canitembereserved = IsAvailableForItemLevelRequest($itemnumber);
494
        my $canitembereserved = IsAvailableForItemLevelRequest($itemnumber);
Lines 609-615 sub HoldTitle { Link Here
609
    my $title = $$biblio{title};
609
    my $title = $$biblio{title};
610
610
611
    # Check if the biblio can be reserved
611
    # Check if the biblio can be reserved
612
    return { code => 'NotHoldable' } unless CanBookBeReserved( $borrowernumber, $biblionumber );
612
    my ($canbookbereserved) = CanBookBeReserved($borrowernumber, $biblionumber);
613
    return { code => 'NotHoldable' } unless $canbookbereserved;
613
614
614
    my $branch;
615
    my $branch;
615
616
Lines 685-692 sub HoldItem { Link Here
685
    return { code => 'RecordNotFound' } if $$item{biblionumber} ne $$biblio{biblionumber};
686
    return { code => 'RecordNotFound' } if $$item{biblionumber} ne $$biblio{biblionumber};
686
687
687
    # Check for item disponibility
688
    # Check for item disponibility
688
    my $canitembereserved = C4::Reserves::CanItemBeReserved( $borrowernumber, $itemnumber );
689
    my ($canitembereserved) = C4::Reserves::CanItemBeReserved( $borrowernumber, $itemnumber );
689
    my $canbookbereserved = C4::Reserves::CanBookBeReserved( $borrowernumber, $biblionumber );
690
    my ($canbookbereserved) = C4::Reserves::CanBookBeReserved( $borrowernumber, $biblionumber );
690
    return { code => 'NotHoldable' } unless $canbookbereserved and $canitembereserved;
691
    return { code => 'NotHoldable' } unless $canbookbereserved and $canitembereserved;
691
692
692
    # Pickup branch management
693
    # Pickup branch management
(-)a/C4/Reserves.pm (-10 / +51 lines)
Lines 431-443 sub GetReservesFromBorrowernumber { Link Here
431
#-------------------------------------------------------------------------------------
431
#-------------------------------------------------------------------------------------
432
=head2 CanBookBeReserved
432
=head2 CanBookBeReserved
433
433
434
  $error = &CanBookBeReserved($borrowernumber, $biblionumber)
434
  ($can_be_reserved, $reasons) = &CanBookBeReserved($borrowernumber, $biblionumber)
435
436
$can_be_reserved is true if book can be reserved, false otherwise.
437
438
$reasons is a hashref where keys are reasons why a book cannot be reserved
439
(undef if $can_be_reserved is true)
440
$reasons keys can be: alreadyreserved, maxreserves or noholdableitems.
435
441
436
=cut
442
=cut
437
443
438
sub CanBookBeReserved{
444
sub CanBookBeReserved{
439
    my ($borrowernumber, $biblionumber) = @_;
445
    my ($borrowernumber, $biblionumber) = @_;
440
446
447
    # Check if borrower already has reserved the same biblio.
448
    my @reserves = GetReservesFromBorrowernumber($borrowernumber);
449
    foreach my $reserve (@reserves) {
450
        if ($reserve->{biblionumber} == $biblionumber) {
451
            return (0, {alreadyreserved => 1});
452
        }
453
    }
454
455
    # Check if borrower has reached the maximum number of holds allowed
456
    my $maxreserves = C4::Context->preference('maxreserves');
457
    if ($maxreserves && scalar(@reserves) >= $maxreserves) {
458
        return (0, {maxreserves => 1});
459
    }
460
441
    my $items = GetItemnumbersForBiblio($biblionumber);
461
    my $items = GetItemnumbersForBiblio($biblionumber);
442
    #get items linked via host records
462
    #get items linked via host records
443
    my @hostitems = get_hostitemnumbers_of($biblionumber);
463
    my @hostitems = get_hostitemnumbers_of($biblionumber);
Lines 446-461 sub CanBookBeReserved{ Link Here
446
    }
466
    }
447
467
448
    foreach my $item (@$items){
468
    foreach my $item (@$items){
449
        return 1 if CanItemBeReserved($borrowernumber, $item);
469
        my ($canitembereserved) = CanItemBeReserved($borrowernumber, $item);
470
        return 1 if $canitembereserved;
450
    }
471
    }
451
    return 0;
472
    return (0, {noholdableitems => 1});
452
}
473
}
453
474
454
=head2 CanItemBeReserved
475
=head2 CanItemBeReserved
455
476
456
  $error = &CanItemBeReserved($borrowernumber, $itemnumber)
477
  ($can_be_reserved, $reasons) = &CanItemBeReserved($borrowernumber, $itemnumber)
478
479
$can_be_reserved is true if book can be reserved, false otherwise.
457
480
458
This function return 1 if an item can be issued by this borrower.
481
$reasons is a hashref where keys are reasons why an item cannot be reserved
482
(undef if $can_be_reserved is true)
483
$reasons keys can be: damaged, alreadyreserved, maxreserves or wrongbranch.
459
484
460
=cut
485
=cut
461
486
Lines 464-478 sub CanItemBeReserved{ Link Here
464
    
489
    
465
    my $dbh             = C4::Context->dbh;
490
    my $dbh             = C4::Context->dbh;
466
    my $allowedreserves = 0;
491
    my $allowedreserves = 0;
467
            
492
468
    # we retrieve borrowers and items informations #
493
    # we retrieve borrowers and items informations #
469
    my $item = GetItem($itemnumber);
494
    my $item = GetItem($itemnumber);
470
495
471
    # If an item is damaged and we don't allow holds on damaged items, we can stop right here
496
    # If an item is damaged and we don't allow holds on damaged items, we can stop right here
472
    return 0 if ( $item->{damaged} && !C4::Context->preference('AllowHoldsOnDamagedItems') );
497
    return (0, {damaged => 1}) if ( $item->{damaged} && !C4::Context->preference('AllowHoldsOnDamagedItems') );
473
498
474
    my $borrower = C4::Members::GetMember('borrowernumber'=>$borrowernumber);     
499
    my $borrower = C4::Members::GetMember('borrowernumber'=>$borrowernumber);     
475
    
500
501
    # Check if borrower already has reserved the same item or biblio.
502
    my @reserves = GetReservesFromBorrowernumber($borrowernumber);
503
    foreach my $reserve (@reserves) {
504
        if (   $reserve->{itemnumber} == $itemnumber
505
            or $reserve->{biblionumber} == $item->{biblionumber} )
506
        {
507
            return (0, {alreadyreserved => 1});
508
        }
509
    }
510
511
    # Check if borrower has reached the maximum number of holds allowed
512
    my $maxreserves = C4::Context->preference('maxreserves');
513
    if ($maxreserves && scalar(@reserves) >= $maxreserves) {
514
        return (0, {maxreserves => 1});
515
    }
516
476
    my $controlbranch = C4::Context->preference('ReservesControlBranch');
517
    my $controlbranch = C4::Context->preference('ReservesControlBranch');
477
    my $itype         = C4::Context->preference('item-level_itypes') ? "itype" : "itemtype";
518
    my $itype         = C4::Context->preference('item-level_itypes') ? "itype" : "itemtype";
478
519
Lines 540-546 sub CanItemBeReserved{ Link Here
540
    
581
    
541
    # we check if it's ok or not
582
    # we check if it's ok or not
542
    if( $reservecount >= $allowedreserves ){
583
    if( $reservecount >= $allowedreserves ){
543
        return 0;
584
        return (0, {maxreserves => 1});
544
    }
585
    }
545
586
546
    # If reservecount is ok, we check item branch if IndependentBranches is ON
587
    # If reservecount is ok, we check item branch if IndependentBranches is ON
Lines 550-556 sub CanItemBeReserved{ Link Here
550
    {
591
    {
551
        my $itembranch = $item->{homebranch};
592
        my $itembranch = $item->{homebranch};
552
        if ($itembranch ne $borrower->{branchcode}) {
593
        if ($itembranch ne $borrower->{branchcode}) {
553
            return 0;
594
            return (0, {wrongbranch => 1});
554
        }
595
        }
555
    }
596
    }
556
597
(-)a/opac/opac-reserve.pl (-17 / +14 lines)
Lines 37-44 use C4::Debug; Link Here
37
use Koha::DateUtils;
37
use Koha::DateUtils;
38
# use Data::Dumper;
38
# use Data::Dumper;
39
39
40
my $MAXIMUM_NUMBER_OF_RESERVES = C4::Context->preference("maxreserves");
41
42
my $query = new CGI;
40
my $query = new CGI;
43
my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
41
my ( $template, $borrowernumber, $cookie ) = get_template_and_user(
44
    {
42
    {
Lines 169-179 foreach my $biblioNumber (@biblionumbers) { Link Here
169
# with a specific item for each biblionumber.
167
# with a specific item for each biblionumber.
170
#
168
#
171
#
169
#
170
my $maxreserves = 0;
172
if ( $query->param('place_reserve') ) {
171
if ( $query->param('place_reserve') ) {
173
    my $reserve_cnt = 0;
172
    my $reserve_cnt = 0;
174
    if ($MAXIMUM_NUMBER_OF_RESERVES) {
175
        $reserve_cnt = GetReservesFromBorrowernumber( $borrowernumber );
176
    }
177
173
178
    # List is composed of alternating biblio/item/branch
174
    # List is composed of alternating biblio/item/branch
179
    my $selectedItems = $query->param('selecteditems');
175
    my $selectedItems = $query->param('selecteditems');
Lines 238-245 if ( $query->param('place_reserve') ) { Link Here
238
      # If a specific item was selected and the pickup branch is the same as the
234
      # If a specific item was selected and the pickup branch is the same as the
239
      # holdingbranch, force the value $rank and $found.
235
      # holdingbranch, force the value $rank and $found.
240
        my $rank = $biblioData->{rank};
236
        my $rank = $biblioData->{rank};
237
        my $reasons;
241
        if ( $itemNum ne '' ) {
238
        if ( $itemNum ne '' ) {
242
            $canreserve = 1 if CanItemBeReserved( $borrowernumber, $itemNum );
239
            ($canreserve, $reasons) = CanItemBeReserved( $borrowernumber, $itemNum );
243
            $rank = '0' unless C4::Context->preference('ReservesNeedReturns');
240
            $rank = '0' unless C4::Context->preference('ReservesNeedReturns');
244
            my $item = GetItem($itemNum);
241
            my $item = GetItem($itemNum);
245
            if ( $item->{'holdingbranch'} eq $branch ) {
242
            if ( $item->{'holdingbranch'} eq $branch ) {
Lines 248-265 if ( $query->param('place_reserve') ) { Link Here
248
            }
245
            }
249
        }
246
        }
250
        else {
247
        else {
251
            $canreserve = 1 if CanBookBeReserved( $borrowernumber, $biblioNum );
248
            ($canreserve, $reasons) = CanBookBeReserved( $borrowernumber, $biblioNum );
252
249
253
            # Inserts a null into the 'itemnumber' field of 'reserves' table.
250
            # Inserts a null into the 'itemnumber' field of 'reserves' table.
254
            $itemNum = undef;
251
            $itemNum = undef;
255
        }
252
        }
256
        my $notes = $query->param('notes_'.$biblioNum)||'';
257
253
258
        if (   $MAXIMUM_NUMBER_OF_RESERVES
254
        my $notes = $query->param('notes_'.$biblioNum)||'';
259
            && $reserve_cnt >= $MAXIMUM_NUMBER_OF_RESERVES )
260
        {
261
            $canreserve = 0;
262
        }
263
255
264
        # Here we actually do the reserveration. Stage 3.
256
        # Here we actually do the reserveration. Stage 3.
265
        if ($canreserve) {
257
        if ($canreserve) {
Lines 271-277 if ( $query->param('place_reserve') ) { Link Here
271
                $notes,       $biblioData->{title},
263
                $notes,       $biblioData->{title},
272
                $itemNum,     $found
264
                $itemNum,     $found
273
            );
265
            );
274
            ++$reserve_cnt;
266
        } else {
267
            if ( $reasons->{maxreserves} ) {
268
                $maxreserves = 1;
269
            }
275
        }
270
        }
276
    }
271
    }
277
272
Lines 317-323 if ( $borr->{'debarred'} ) { Link Here
317
312
318
my @reserves = GetReservesFromBorrowernumber( $borrowernumber );
313
my @reserves = GetReservesFromBorrowernumber( $borrowernumber );
319
$template->param( RESERVES => \@reserves );
314
$template->param( RESERVES => \@reserves );
320
if ( $MAXIMUM_NUMBER_OF_RESERVES && (scalar(@reserves) >= $MAXIMUM_NUMBER_OF_RESERVES) ) {
315
if ($maxreserves) {
321
    $template->param( message => 1 );
316
    $template->param( message => 1 );
322
    $noreserves = 1;
317
    $noreserves = 1;
323
    $template->param( too_many_reserves => scalar(@reserves));
318
    $template->param( too_many_reserves => scalar(@reserves));
Lines 502-508 foreach my $biblioNum (@biblionumbers) { Link Here
502
            $policy_holdallowed = 0;
497
            $policy_holdallowed = 0;
503
        }
498
        }
504
499
505
        if (IsAvailableForItemLevelRequest($itemNum) and $policy_holdallowed and CanItemBeReserved($borrowernumber,$itemNum) and ($itemLoopIter->{already_reserved} ne 1)) {
500
        my ($canitembereserved) = CanItemBeReserved($borrowernumber, $itemNum);
501
        if (IsAvailableForItemLevelRequest($itemNum) and $policy_holdallowed and $canitembereserved and ($itemLoopIter->{already_reserved} ne 1)) {
506
            $itemLoopIter->{available} = 1;
502
            $itemLoopIter->{available} = 1;
507
            $numCopiesAvailable++;
503
            $numCopiesAvailable++;
508
        }
504
        }
Lines 526-532 foreach my $biblioNum (@biblionumbers) { Link Here
526
    if ($biblioLoopIter{already_reserved}) {
522
    if ($biblioLoopIter{already_reserved}) {
527
        $biblioLoopIter{holdable} = undef;
523
        $biblioLoopIter{holdable} = undef;
528
    }
524
    }
529
    if(not CanBookBeReserved($borrowernumber,$biblioNum)){
525
    my ($canbookbereserved) = CanBookBeReserved($borrowernumber, $biblioNum);
526
    if(not $canbookbereserved){
530
        $biblioLoopIter{holdable} = undef;
527
        $biblioLoopIter{holdable} = undef;
531
    }
528
    }
532
    if(not C4::Context->preference('AllowHoldsOnPatronsPossessions') and CheckIfIssuedToPatron($borrowernumber,$biblioNum)) {
529
    if(not C4::Context->preference('AllowHoldsOnPatronsPossessions') and CheckIfIssuedToPatron($borrowernumber,$biblioNum)) {
(-)a/reserve/request.pl (-18 / +18 lines)
Lines 186-193 foreach my $biblionumber (@biblionumbers) { Link Here
186
186
187
    my $dat = GetBiblioData($biblionumber);
187
    my $dat = GetBiblioData($biblionumber);
188
188
189
    unless ( CanBookBeReserved($borrowerinfo->{borrowernumber}, $biblionumber) ) {
189
    my $alreadyreserved = 0;
190
        $maxreserves = 1;
190
191
    my ($can_book_be_reserved, $reasons) =
192
      CanBookBeReserved( $borrowerinfo->{borrowernumber}, $biblionumber );
193
194
    unless ($can_book_be_reserved) {
195
        if ($reasons->{alreadyreserved}) {
196
            $alreadyreserved = 1;
197
            $biblioloopiter{warn} = 1;
198
            $biblioloopiter{alreadyres} = 1;
199
        } else {
200
            $maxreserves = 1;
201
        }
191
    }
202
    }
192
203
193
    my $alreadypossession;
204
    my $alreadypossession;
Lines 199-221 foreach my $biblionumber (@biblionumbers) { Link Here
199
    my $reserves = GetReservesFromBiblionumber({ biblionumber => $biblionumber, all_dates => 1 });
210
    my $reserves = GetReservesFromBiblionumber({ biblionumber => $biblionumber, all_dates => 1 });
200
    my $count = scalar( @$reserves );
211
    my $count = scalar( @$reserves );
201
    my $totalcount = $count;
212
    my $totalcount = $count;
202
    my $holds_count = 0;
203
    my $alreadyreserved = 0;
204
213
205
    foreach my $res (@$reserves) {
214
    foreach my $res (@$reserves) {
206
        if ( defined $res->{found} && $res->{found} eq 'W' ) {
215
        if ( defined $res->{found} && $res->{found} eq 'W' ) {
207
            $count--;
216
            $count--;
208
        }
217
        }
209
210
        if ( defined $borrowerinfo && defined($borrowerinfo->{borrowernumber}) && ($borrowerinfo->{borrowernumber} eq $res->{borrowernumber}) ) {
211
            $holds_count++;
212
        }
213
    }
214
215
    if ( $holds_count ) {
216
            $alreadyreserved = 1;
217
            $biblioloopiter{warn} = 1;
218
            $biblioloopiter{alreadyres} = 1;
219
    }
218
    }
220
219
221
    $template->param(
220
    $template->param(
Lines 403-416 foreach my $biblionumber (@biblionumbers) { Link Here
403
                     $borrowerinfo->{'branchcode'} ne $item->{'homebranch'} ) ) {
402
                     $borrowerinfo->{'branchcode'} ne $item->{'homebranch'} ) ) {
404
                $policy_holdallowed = 0;
403
                $policy_holdallowed = 0;
405
            }
404
            }
406
            
405
406
            my ($canitembereserved) =
407
              CanItemBeReserved( $borrowerinfo->{borrowernumber}, $itemnumber );
408
407
            if (
409
            if (
408
                   $policy_holdallowed
410
                   $policy_holdallowed
409
                && !$item->{cantreserve}
411
                && !$item->{cantreserve}
410
                && IsAvailableForItemLevelRequest($itemnumber)
412
                && IsAvailableForItemLevelRequest($itemnumber)
411
                && CanItemBeReserved(
413
                && $canitembereserved
412
                    $borrowerinfo->{borrowernumber}, $itemnumber
413
                )
414
              )
414
              )
415
            {
415
            {
416
                $item->{available} = 1;
416
                $item->{available} = 1;
(-)a/t/db_dependent/Holds.t (-14 / +59 lines)
Lines 6-12 use t::lib::Mocks; Link Here
6
use C4::Context;
6
use C4::Context;
7
use C4::Branch;
7
use C4::Branch;
8
8
9
use Test::More tests => 29;
9
use Test::More tests => 40;
10
use MARC::Record;
10
use MARC::Record;
11
use C4::Biblio;
11
use C4::Biblio;
12
use C4::Items;
12
use C4::Items;
Lines 49-56 foreach (1..$borrowers_count) { Link Here
49
49
50
my $biblionumber   = $bibnum;
50
my $biblionumber   = $bibnum;
51
51
52
my @branches = GetBranchesLoop();
52
my $branches = GetBranchesLoop();
53
my $branch = $branches[0][0]{value};
53
my $branch = $branches->[0]{value};
54
54
55
# Create five item level holds
55
# Create five item level holds
56
foreach my $borrowernumber ( @borrowernumbers ) {
56
foreach my $borrowernumber ( @borrowernumbers ) {
Lines 194-218 t::lib::Mocks::mock_preference('item-level_itypes', 1); Link Here
194
194
195
# if IndependentBranches is OFF, a CPL patron can reserve an MPL item
195
# if IndependentBranches is OFF, a CPL patron can reserve an MPL item
196
t::lib::Mocks::mock_preference('IndependentBranches', 0);
196
t::lib::Mocks::mock_preference('IndependentBranches', 0);
197
my ($canitembereserved, $reasons) = CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber);
197
ok(
198
ok(
198
    CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber),
199
    $canitembereserved,
199
    'CPL patron allowed to reserve MPL item with IndependentBranches OFF (bug 2394)'
200
    'CPL patron allowed to reserve MPL item with IndependentBranches OFF (bug 2394)'
200
);
201
);
202
is($reasons, undef);
201
203
202
# if IndependentBranches is OFF, a CPL patron cannot reserve an MPL item
204
# if IndependentBranches is OFF, a CPL patron cannot reserve an MPL item
203
t::lib::Mocks::mock_preference('IndependentBranches', 1);
205
t::lib::Mocks::mock_preference('IndependentBranches', 1);
204
t::lib::Mocks::mock_preference('canreservefromotherbranches', 0);
206
t::lib::Mocks::mock_preference('canreservefromotherbranches', 0);
207
($canitembereserved, $reasons) = CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber);
205
ok(
208
ok(
206
    ! CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber),
209
    ! $canitembereserved,
207
    'CPL patron NOT allowed to reserve MPL item with IndependentBranches ON ... (bug 2394)'
210
    'CPL patron NOT allowed to reserve MPL item with IndependentBranches ON ... (bug 2394)'
208
);
211
);
212
ok($reasons->{wrongbranch});
209
213
210
# ... unless canreservefromotherbranches is ON
214
# ... unless canreservefromotherbranches is ON
211
t::lib::Mocks::mock_preference('canreservefromotherbranches', 1);
215
t::lib::Mocks::mock_preference('canreservefromotherbranches', 1);
216
($canitembereserved, $reasons) = CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber);
212
ok(
217
ok(
213
    CanItemBeReserved($borrowernumbers[0], $foreign_itemnumber),
218
    $canitembereserved,
214
    '... unless canreservefromotherbranches is ON (bug 2394)'
219
    '... unless canreservefromotherbranches is ON (bug 2394)'
215
);
220
);
221
is($reasons, undef);
216
222
217
# Regression test for bug 11336
223
# Regression test for bug 11336
218
($bibnum, $title, $bibitemnum) = create_helper_biblio();
224
($bibnum, $title, $bibitemnum) = create_helper_biblio();
Lines 278-299 ModReserve({ reserve_id => $reserveid2, rank => 'del' }); Link Here
278
$reserve3 = GetReserve( $reserveid3 );
284
$reserve3 = GetReserve( $reserveid3 );
279
is( $reserve3->{priority}, 1, "After ModReserve, the 3rd reserve becomes the first on the waiting list" );
285
is( $reserve3->{priority}, 1, "After ModReserve, the 3rd reserve becomes the first on the waiting list" );
280
286
281
ModItem({ damaged => 1 }, $item_bibnum, $itemnumber);
282
C4::Context->set_preference( 'AllowHoldsOnDamagedItems', 1 );
287
C4::Context->set_preference( 'AllowHoldsOnDamagedItems', 1 );
283
ok( CanItemBeReserved( $borrowernumbers[0], $itemnumber), "Patron can reserve damaged item with AllowHoldsOnDamagedItems enabled" );
284
ok( defined( ( CheckReserves($itemnumber) )[1] ), "Hold can be trapped for damaged item with AllowHoldsOnDamagedItems enabled" );
288
ok( defined( ( CheckReserves($itemnumber) )[1] ), "Hold can be trapped for damaged item with AllowHoldsOnDamagedItems enabled" );
289
290
CancelReserve({reserve_id => $reserveid3});
291
ModItem({ damaged => 1 }, $item_bibnum, $itemnumber);
292
($canitembereserved, $reasons) = CanItemBeReserved($borrowernumbers[0], $itemnumber);
293
ok( $canitembereserved, "Patron can reserve damaged item with AllowHoldsOnDamagedItems enabled" );
294
is($reasons, undef);
295
285
C4::Context->set_preference( 'AllowHoldsOnDamagedItems', 0 );
296
C4::Context->set_preference( 'AllowHoldsOnDamagedItems', 0 );
286
ok( !CanItemBeReserved( $borrowernumbers[0], $itemnumber), "Patron cannot reserve damaged item with AllowHoldsOnDamagedItems disabled" );
297
($canitembereserved, $reasons) = CanItemBeReserved($borrowernumbers[0], $itemnumber);
298
ok( !$canitembereserved, "Patron cannot reserve damaged item with AllowHoldsOnDamagedItems disabled" );
299
ok($reasons->{damaged});
287
ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for damaged item with AllowHoldsOnDamagedItems disabled" );
300
ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for damaged item with AllowHoldsOnDamagedItems disabled" );
288
301
302
AddReserve(
303
    $branch,
304
    $borrowernumbers[0],
305
    $biblionumber,
306
    'a',
307
    '',
308
    1,
309
);
310
311
my $canbookbereserved;
312
($canbookbereserved, $reasons) = CanBookBeReserved($borrowernumbers[0], $biblionumber);
313
ok(!$canbookbereserved);
314
ok($reasons->{alreadyreserved});
315
316
C4::Context->set_preference('maxreserves', 1);
317
($canbookbereserved, $reasons) = CanBookBeReserved($borrowernumbers[0], $bibnum);
318
ok(!$canbookbereserved);
319
ok($reasons->{maxreserves});
320
321
C4::Context->set_preference('maxreserves', 0);
322
t::lib::Mocks::mock_preference('IndependentBranches', 1);
323
t::lib::Mocks::mock_preference('canreservefromotherbranches', 0);
324
($canbookbereserved, $reasons) = CanBookBeReserved($borrowernumbers[0], $foreign_bibnum);
325
ok(!$canbookbereserved);
326
ok($reasons->{noholdableitems});
327
289
328
290
# Helper method to set up a Biblio.
329
# Helper method to set up a Biblio.
291
sub create_helper_biblio {
330
sub create_helper_biblio {
292
    my $bib = MARC::Record->new();
331
    my $bib = MARC::Record->new();
293
    my $title = 'Silence in the library';
332
    my $title = 'Silence in the library';
294
    $bib->append_fields(
333
    if (C4::Context->preference('marcflavour') eq 'UNIMARC') {
295
        MARC::Field->new('100', ' ', ' ', a => 'Moffat, Steven'),
334
        $bib->append_fields(
296
        MARC::Field->new('245', ' ', ' ', a => $title),
335
            MARC::Field->new('600', '', '1', a => 'Moffat, Steven'),
297
    );
336
            MARC::Field->new('200', '', '', a => $title),
337
        );
338
    } else {
339
        $bib->append_fields(
340
            MARC::Field->new('100', ' ', ' ', a => 'Moffat, Steven'),
341
            MARC::Field->new('245', ' ', ' ', a => $title),
342
        );
343
    }
298
    return ($bibnum, $title, $bibitemnum) = AddBiblio($bib, '');
344
    return ($bibnum, $title, $bibitemnum) = AddBiblio($bib, '');
299
}
345
}
300
- 

Return to bug 11999