Attachment #129253 for bug #29562

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





    ## check for high holds decreasing loan period
    if ( C4::Context->preference('decreaseLoanHighHolds') ) {
        my $check = checkHighHolds( $item_object, $patron );

        if ( $check->{exceeded} ) {
            if ($override_high_holds) {

=cut

sub checkHighHolds {
    my ( $item, $patron ) = @_;
    my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
    my $item_object = Koha::Items->find( $item->{itemnumber} );

    my $return_data = {
        exceeded    => 0,

        due_date    => undef,
    };

    my $holds = Koha::Holds->search( { biblionumber => $item->biblionumber } );

    if ( $holds->count() ) {
        $return_data->{outstanding} = $holds->count();

            }

            # Remove any items that are not holdable for this patron
            @items = grep { CanItemBeReserved( $patron , $_, undef, { ignore_found_holds => 1 } )->{status} eq 'OK' } @items;

            my $items_count = scalar @items;



        my $issuedate = dt_from_string();

        my $itype = $item->effective_itemtype;
        my $daysmode = Koha::CirculationRules->get_effective_daysmode(
            {
                categorycode => $patron->categorycode,
                itemtype     => $itype,
                branchcode   => $branchcode,
            }
        );
        my $calendar = Koha::Calendar->new( branchcode => $branchcode, days_mode => $daysmode );

        my $orig_due = C4::Circulation::CalcDateDue( $issuedate, $itype, $branchcode, $patron->unblessed );

        my $rule = Koha::CirculationRules->get_effective_rule(
            {
                categorycode => $patron->categorycode,
                itemtype     => $item->effective_itemtype,
                branchcode   => $branchcode,
                rule_name    => 'decreaseloanholds',
            }

                next if IsItemOnHoldAndFound( $item->itemnumber );
                while ( my $patron = $patrons->next ) {
                    next unless IsAvailableForItemLevelRequest($item, $patron);
                    next unless CanItemBeReserved($patron,$item,undef,{ignore_hold_counts=>1})->{status} eq 'OK';
                    push @reservable, $item->itemnumber;
                    if (@reservable >= @borrowernumbers) {
                        $resfound = 0;

Lines 872-878 sub HoldItem { Link Here

(-)a/C4/ILSDI/Services.pm (-1 / +1 lines)
872	}	872	}
873		873
874	# Check for item disponibility	874	# Check for item disponibility
875	my $canitembereserved = C4::Reserves::CanItemBeReserved( $borrowernumber, $itemnumber, $branch )->{status};	875	my $canitembereserved = C4::Reserves::CanItemBeReserved( $patron, $item, $branch )->{status};
876	return { code => $canitembereserved } unless $canitembereserved eq 'OK';	876	return { code => $canitembereserved } unless $canitembereserved eq 'OK';
877		877
878	my $resdate;	878	my $resdate;




        return { status =>'alreadypossession' };
    }

    my $items;
    #get items linked via host records
    my @hostitemnumbers = get_hostitemnumbers_of($biblionumber);
    if (@hostitemnumbers){
        $items = Koha::Items->search({
            -or => [
                biblionumber => $biblionumber,
                itemnumber => { -in => @hostitemnumbers }
            ]
        });
    } else {
        $items = Koha::Items->search({ biblionumber => $biblionumber});
    }

    my $canReserve = { status => '' };
    my $patron = Koha::Patrons->find( $borrowernumber );
    while ( my $item = $items->next ) {
        $canReserve = CanItemBeReserved( $patron, $item, $pickup_branchcode, $params );
        return { status => 'OK' } if $canReserve->{status} eq 'OK';
    }
    return $canReserve;


=head2 CanItemBeReserved

  $canReserve = &CanItemBeReserved($patron, $item, $branchcode, $params)
  if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }

  current params are:

=cut

sub CanItemBeReserved {
    my ( $patron, $item, $pickup_branchcode, $params ) = @_;

    my $dbh = C4::Context->dbh;
    my $ruleitemtype;    # itemtype of the matching issuing rule


    # we retrieve borrowers and items informations #
    # item->{itype} will come for biblioitems if necessery
    my $item       = Koha::Items->find($itemnumber);
    my $biblio     = $item->biblio;
    my $patron = Koha::Patrons->find( $borrowernumber );
    my $borrower = $patron->unblessed;

    # If an item is damaged and we don't allow holds on damaged items, we can stop right here


    # Check that the patron doesn't have an item level hold on this item already
    return { status =>'itemAlreadyOnHold' }
      if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $patron->borrowernumber, itemnumber => $item->itemnumber } )->count() );

    # Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
    if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')

    my $holds_per_day    = $rights->{holds_per_day};

    my $search_params = {
        borrowernumber => $patron->borrowernumber,
        biblionumber   => $item->biblionumber,
    };
    $search_params->{found} = undef if $params->{ignore_found_holds};

    }

    my $today_holds = Koha::Holds->search({
        borrowernumber => $patron->borrowernumber,
        reservedate    => dt_from_string->date
    });


    my $sthcount = $dbh->prepare($querycount);

    if ( defined $ruleitemtype ) {
        $sthcount->execute( $patron->borrowernumber, $branchcode, $ruleitemtype );
    }
    else {
        $sthcount->execute( $patron->borrowernumber, $branchcode );
    }

    my $reservecount = "0";

    # Now we need to check hold limits by patron category
    my $rule = Koha::CirculationRules->get_effective_rule(
        {
            categorycode => $patron->categorycode,
            branchcode   => $branchcode,
            rule_name    => 'max_holds',
        }

    if (!$params->{ignore_hold_counts} && $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
        my $total_holds_count = Koha::Holds->search(
            {
                borrowernumber => $patron->borrowernumber
            }
        )->count();


    }

    my $reserves_control_branch =
      GetReservesControlBranch( $item->unblessed(), $patron->unblessed );
    my $branchitemrule =
      C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->effective_itemtype );



    my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
    if ( $branchitemrule->{holdallowed} eq 'from_local_hold_group') {
        if($patron->branchcode ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $patron->branchcode} )) {
            return { status => 'branchNotInHoldGroup' };
        }
    }

    if ( C4::Context->preference('IndependentBranches')
        and !C4::Context->preference('canreservefromotherbranches') )
    {
        if ( $item->homebranch ne $patron->branchcode ) {
            return { status => 'cannotReserveFromOtherBranches' };
        }
    }

            || Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
            || $branchitemrule->{holdallowed} eq 'from_home_library' && $param->{patron}->branchcode ne $i->homebranch
            || $branchitemrule->{holdallowed} eq 'from_local_hold_group' && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } )
            || CanItemBeReserved( $param->{patron}, $i )->{status} ne 'OK';
    }

    return 0;

Lines 53-58 Class (static) method that returns a new Koha::Club::Hold instance Link Here

(-)a/Koha/Club/Hold.pm (-5 / +7 lines)
53		53
54	sub add {	54	sub add {
55	my ( $params ) = @_;	55	my ( $params ) = @_;
		56	my $itemnumber = $params->{item_id};
56		57
57	# check for mandatory params	58	# check for mandatory params
58	my @mandatory = ( 'biblio_id', 'club_id' );	59	my @mandatory = ( 'biblio_id', 'club_id' );
Lines 87-97 sub add { Link Here
87	my $pickup_id = $params->{pickup_library_id};	88	my $pickup_id = $params->{pickup_library_id};
88		89
89	my $can_place_hold;	90	my $can_place_hold;
		91	my $patron = Koha::Patrons->find($patron_id);
		92	my $item = $itemnumber ? Koha::Items->find( $itemnumber ) : undef;
90	if($params->{default_patron_home}) {	93	if($params->{default_patron_home}) {
91	my $patron = Koha::Patrons->find($patron_id);
92	my $patron_home = $patron->branchcode;	94	my $patron_home = $patron->branchcode;
93	$can_place_hold = $params->{item_id}	95	$can_place_hold = $itemnumber
94	? C4::Reserves::CanItemBeReserved( $patron_id, $params->{item_id}, $patron_home )	96	? C4::Reserves::CanItemBeReserved( $patron, $item, $patron_home )
95	: C4::Reserves::CanBookBeReserved( $patron_id, $params->{biblio_id}, $patron_home );	97	: C4::Reserves::CanBookBeReserved( $patron_id, $params->{biblio_id}, $patron_home );
96	$pickup_id = $patron_home if $can_place_hold->{status} eq 'OK';	98	$pickup_id = $patron_home if $can_place_hold->{status} eq 'OK';
97	unless ( $can_place_hold->{status} eq 'OK' ) {	99	unless ( $can_place_hold->{status} eq 'OK' ) {
Lines 100-107 sub add { Link Here
100	}	102	}
101		103
102	unless ( defined $can_place_hold && $can_place_hold->{status} eq 'OK' ) {	104	unless ( defined $can_place_hold && $can_place_hold->{status} eq 'OK' ) {
103	$can_place_hold = $params->{item_id}	105	$can_place_hold = $itemnumber
104	? C4::Reserves::CanItemBeReserved( $patron_id, $params->{item_id}, $pickup_id )	106	? C4::Reserves::CanItemBeReserved( $patron, $item, $pickup_id )
105	: C4::Reserves::CanBookBeReserved( $patron_id, $params->{biblio_id}, $pickup_id );	107	: C4::Reserves::CanBookBeReserved( $patron_id, $params->{biblio_id}, $pickup_id );
106	}	108	}
107		109

Lines 166-172 sub add { Link Here

(-)a/Koha/REST/V1/Holds.pm (-1 / +1 lines)
166		166
167	my $can_place_hold	167	my $can_place_hold
168	= $item_id	168	= $item_id
169	? C4::Reserves::CanItemBeReserved( $patron_id, $item_id )	169	? C4::Reserves::CanItemBeReserved( $patron, $item )
170	: C4::Reserves::CanBookBeReserved( $patron_id, $biblio_id );	170	: C4::Reserves::CanBookBeReserved( $patron_id, $biblio_id );
171		171
172	if ( $patron->holds->count + 1 > C4::Context->preference('maxreserves') ) {	172	if ( $patron->holds->count + 1 > C4::Context->preference('maxreserves') ) {




            $branch = $patron->branchcode;
        }

        my $item = $itemNum ? Koha::Items->find( $itemNum ) : undef;
        # When choosing a specific item, the default pickup library should be dictated by the default hold policy
        if ( ! C4::Context->preference("OPACAllowUserToChooseBranch") && $itemNum ) {
            my $item = Koha::Items->find( $itemNum );
            my $type = $item->effective_itemtype;
            my $rule = GetBranchItemRule( $patron->branchcode, $type );


        }

#item may belong to a host biblio, if yes change biblioNum to hosts bilbionumber
        if ( $itemNum ) {
            my $item = Koha::Items->find( $itemNum );
            my $hostbiblioNum = $item->biblio->biblionumber;
            if ( $hostbiblioNum ne $biblioNum ) {
                $biblioNum = $hostbiblioNum;

        my $expiration_date = $query->param("expiration_date_$biblioNum");

        my $rank = $biblioData->{rank};
        my $patron = Koha::Patrons->find( $borrowernumber );
        if ( $itemNum ) {
            $canreserve = 1 if CanItemBeReserved( $patron, $item, $branch )->{status} eq 'OK';
        }
        else {
            $canreserve = 1 if CanBookBeReserved( $borrowernumber, $biblioNum, $branch )->{status} eq 'OK';

        my $policy_holdallowed = !$itemLoopIter->{already_reserved};
        $policy_holdallowed &&=
            IsAvailableForItemLevelRequest($item, $patron) &&
            CanItemBeReserved( $patron, $item )->{status} eq 'OK';

        if ($policy_holdallowed) {
            my $opac_hold_policy = Koha::CirculationRules->get_opacitemholds_policy( { item => $item, patron => $patron } );




my $itemtype       = $input->param('itemtype') || undef;
my $non_priority   = $input->param('non_priority');

my $patron = Koha::Patrons->find( $borrowernumber );
$borrower = $borrower->unblessed if $borrower;

my $biblionumbers = $input->param('biblionumbers');
$biblionumbers ||= $biblionumber . '/';


my $found;

if ( $type eq 'str8' && $patron ) {

    foreach my $biblionumber ( keys %bibinfos ) {
        my $count = @bibitems;

                $biblionumber = $item->biblionumber;
            }

            my $can_item_be_reserved = CanItemBeReserved($patron, $item, $item_pickup_location)->{status};

            if ( $can_item_be_reserved eq 'OK' || ( $can_item_be_reserved ne 'itemAlreadyOnHold' && $can_override ) ) {
                AddReserve(
                    {
                        branchcode       => $item_pickup_location,
                        borrowernumber   => $patron->borrowernumber,
                        biblionumber     => $biblionumber,
                        priority         => $rank[0],
                        reservation_date => $startdate,


        } elsif (@biblionumbers > 1) {
            my $bibinfo = $bibinfos{$biblionumber};
            if ( $can_override || CanBookBeReserved($patron->borrowernumber, $biblionumber)->{status} eq 'OK' ) {
                AddReserve(
                    {
                        branchcode       => $bibinfo->{pickup},
                        borrowernumber   => $patron->borrowernumber,
                        biblionumber     => $biblionumber,
                        priority         => $bibinfo->{rank},
                        reservation_date => $startdate,

        } else {
            # place a request on 1st available
            for ( my $i = 0 ; $i < $holds_to_place_count ; $i++ ) {
                if ( $can_override || CanBookBeReserved($patron->borrowernumber, $biblionumber)->{status} eq 'OK' ) {
                    AddReserve(
                        {
                            branchcode       => $branch,
                            borrowernumber   => $patron->borrowernumber,
                            biblionumber     => $biblionumber,
                            priority         => $rank[0],
                            reservation_date => $startdate,

Lines 565-571 foreach my $biblionumber (@biblionumbers) { Link Here

(-)a/reserve/request.pl (-1 / +1 lines)
565		565
566	$item->{'holdallowed'} = $branchitemrule->{'holdallowed'};	566	$item->{'holdallowed'} = $branchitemrule->{'holdallowed'};
567		567
568	my $can_item_be_reserved = CanItemBeReserved( $patron->borrowernumber, $itemnumber )->{status};	568	my $can_item_be_reserved = CanItemBeReserved( $patron, $item_object )->{status};
569	$item->{not_holdable} = $can_item_be_reserved unless ( $can_item_be_reserved eq 'OK' );	569	$item->{not_holdable} = $can_item_be_reserved unless ( $can_item_be_reserved eq 'OK' );
570		570
571	$item->{item_level_holds} = Koha::CirculationRules->get_opacitemholds_policy( { item => $item_object, patron => $patron } );	571	$item->{item_level_holds} = Koha::CirculationRules->get_opacitemholds_policy( { item => $item_object, patron => $patron } );





# Create some borrowers
my @borrowernumbers;
my @patrons;
foreach (1..$borrowers_count) {
    my $patron = Koha::Patron->new({
        firstname =>  'my firstname',
        surname => 'my surname ' . $_,
        categorycode => $category->{categorycode},
        branchcode => $branch_1,
    })->store;
    push @patrons, $patron;
    push @borrowernumbers, $patron->borrowernumber;
}

# Create five item level holds

# IndependentBranches is OFF.

my $foreign_biblio = $builder->build_sample_biblio({ itemtype => 'DUMMY' });
my $foreign_item = $builder->build_sample_item({ library => $branch_2, biblionumber => $foreign_biblio->biblionumber });
Koha::CirculationRules->set_rules(
    {
        categorycode => undef,

t::lib::Mocks::mock_preference('IndependentBranches', 0);

is(
    CanItemBeReserved($patrons[0], $foreign_item)->{status}, 'OK',
    '$branch_1 patron allowed to reserve $branch_2 item with IndependentBranches OFF (bug 2394)'
);


t::lib::Mocks::mock_preference('IndependentBranches', 1);
t::lib::Mocks::mock_preference('canreservefromotherbranches', 0);
ok(
    CanItemBeReserved($patrons[0], $foreign_item)->{status} eq 'cannotReserveFromOtherBranches',
    '$branch_1 patron NOT allowed to reserve $branch_2 item with IndependentBranches ON ... (bug 2394)'
);

# ... unless canreservefromotherbranches is ON
t::lib::Mocks::mock_preference('canreservefromotherbranches', 1);
ok(
    CanItemBeReserved($patrons[0], $foreign_item)->{status} eq 'OK',
    '... unless canreservefromotherbranches is ON (bug 2394)'
);


    is( $hold3->discard_changes->priority, 1, "After ModReserve, the 3rd reserve becomes the first on the waiting list" );
}

my $damaged_item = Koha::Items->find($itemnumber)->damaged(1)->store; # FIXME The $itemnumber is a bit confusing here
t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 1 );
is( CanItemBeReserved( $patrons[0], $damaged_item)->{status}, 'OK', "Patron can reserve damaged item with AllowHoldsOnDamagedItems enabled" );
ok( defined( ( CheckReserves($itemnumber) )[1] ), "Hold can be trapped for damaged item with AllowHoldsOnDamagedItems enabled" );

$hold = Koha::Hold->new(

        biblionumber   => $biblio->biblionumber,
    }
)->store();
is( CanItemBeReserved( $patrons[0], $damaged_item )->{status},
    'itemAlreadyOnHold',
    "Patron cannot place a second item level hold for a given item" );
$hold->delete();

t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 0 );
ok( CanItemBeReserved( $patrons[0], $damaged_item)->{status} eq 'damaged', "Patron cannot reserve damaged item with AllowHoldsOnDamagedItems disabled" );
ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for damaged item with AllowHoldsOnDamagedItems disabled" );

# Items that are not for loan, but holdable should not be trapped until they are available for loan
t::lib::Mocks::mock_preference( 'TrapHoldsOnOrder', 0 );
my $nfl_item = Koha::Items->find($itemnumber)->damaged(0)->notforloan(-1)->store;
Koha::Holds->search({ biblionumber => $biblio->id })->delete();
is( CanItemBeReserved( $patrons[0], $nfl_item)->{status}, 'OK', "Patron can place hold on item that is not for loan but holdable ( notforloan < 0 )" );
$hold = Koha::Hold->new(
    {
        borrowernumber => $borrowernumbers[0],

t::lib::Mocks::mock_preference( 'SkipHoldTrapOnNotForLoanValue', '-1|1' );
ok( !defined( ( CheckReserves($itemnumber) )[1] ), "Hold cannot be trapped for item with notforloan value matching SkipHoldTrapOnNotForLoanValue" );
is(
    CanItemBeReserved( $patrons[0], $nfl_item)->{status}, 'itemAlreadyOnHold',
    "cannot request item that you have already reservedd"
);
is(
    CanItemBeReserved( $patrons[0], $item, undef, { ignore_hold_counts => 1 })->{status}, 'OK',
    "can request item if we are not checking holds counts, but only if policy allows or forbids it"
);
$hold->delete();

    }
);
is(
    CanItemBeReserved( $patrons[0], $item)->{status}, 'noReservesAllowed',
    "cannot request item if policy that matches on item-level item type forbids it"
);
is(
    CanItemBeReserved( $patrons[0], $item, undef, { ignore_hold_counts => 1 })->{status}, 'noReservesAllowed',
    "cannot request item if policy that matches on item-level item type forbids it even if ignoring counts"
);


        my $biblionumber_can = $builder->build_sample_biblio({ itemtype => $itemtype_can })->biblionumber;
        my $biblionumber_record_cannot = $builder->build_sample_biblio({ itemtype => $itemtype_cant_record })->biblionumber;

        my $item_1_can = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_can, biblionumber => $biblionumber_cannot });
        my $item_1_cannot = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_cant, biblionumber => $biblionumber_cannot });
        my $item_2_can = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_can, biblionumber => $biblionumber_can });
        my $item_2_cannot = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_cant, biblionumber => $biblionumber_can });
        my $item_3_cannot = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_cant_record, biblionumber => $biblionumber_record_cannot });

        Koha::Holds->search({borrowernumber => $borrowernumbers[0]})->delete;

        t::lib::Mocks::mock_preference('item-level_itypes', 1);
        is(
            CanItemBeReserved( $patrons[0], $item_2_cannot)->{status}, 'noReservesAllowed',
            "With item level set, rule from item must be picked (CANNOT)"
        );
        is(
            CanItemBeReserved( $patrons[0], $item_1_can)->{status}, 'OK',
            "With item level set, rule from item must be picked (CAN)"
        );
        t::lib::Mocks::mock_preference('item-level_itypes', 0);
        is(
            CanItemBeReserved( $patrons[0], $item_1_can)->{status}, 'noReservesAllowed',
            "With biblio level set, rule from biblio must be picked (CANNOT)"
        );
        is(
            CanItemBeReserved( $patrons[0], $item_2_cannot)->{status}, 'OK',
            "With biblio level set, rule from biblio must be picked (CAN)"
        );
        is(
            CanItemBeReserved( $patrons[0], $item_3_cannot)->{status}, 'noReservesAllowed',
            "When no holds allowed and no holds per record allowed should return noReservesAllowed"
        );
    };

        plan tests => 7;

        my $biblionumber_1 = $builder->build_sample_biblio({ itemtype => $itemtype_can })->biblionumber;
        my $item_11 = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_can, biblionumber => $biblionumber_1 });
        my $item_12 = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_can, biblionumber => $biblionumber_1 });
        my $biblionumber_2 = $builder->build_sample_biblio({ itemtype => $itemtype_can })->biblionumber;
        my $item_21 = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_can, biblionumber => $biblionumber_2 });
        my $item_22 = $builder->build_sample_item({ homebranch => $branch_1, holdingbranch => $branch_1, itype => $itemtype_can, biblionumber => $biblionumber_2 });

        Koha::Holds->search({borrowernumber => $borrowernumbers[0]})->delete;


            t::lib::Mocks::mock_preference('item-level_itypes', $item_level);
            is(
                # FIXME This is not really correct, but CanItemBeReserved does not check if biblio-level holds already exist
                CanItemBeReserved( $patrons[0], $item_11)->{status}, 'OK',
                "A biblio-level hold already exists - another hold can be placed on a specific item item"
            );
        }

            branch => $branch_1,
            borrowernumber => $borrowernumbers[0],
            biblionumber => $biblionumber_1,
            itemnumber => $item_11->itemnumber,
        });

        $dbh->do('DELETE FROM circulation_rules');

            }
        );
        is(
            CanItemBeReserved( $patrons[0], $item_12)->{status}, 'tooManyHoldsForThisRecord',
            "A item-level hold already exists and holds_per_record=1, another hold cannot be placed on this record"
        );
        Koha::CirculationRules->set_rules(

            }
        );
        is(
            CanItemBeReserved( $patrons[0], $item_12)->{status}, 'tooManyHoldsForThisRecord',
            "A item-level hold already exists and holds_per_record=1 - tooManyHoldsForThisRecord has priority over tooManyReserves"
        );
        Koha::CirculationRules->set_rules(

            }
        );
        is(
            CanItemBeReserved( $patrons[0], $item_12)->{status}, 'OK',
            "A item-level hold already exists but holds_per_record=2- another item-level hold can be placed on this record"
        );


            branch => $branch_1,
            borrowernumber => $borrowernumbers[0],
            biblionumber => $biblionumber_2,
            itemnumber => $item_21->itemnumber
        });
        Koha::CirculationRules->set_rules(
            {

            }
        );
        is(
            CanItemBeReserved( $patrons[0], $item_21)->{status}, 'itemAlreadyOnHold',
            "A item-level holds already exists on this item, itemAlreadyOnHold should be raised"
        );
        is(
            CanItemBeReserved( $patrons[0], $item_22)->{status}, 'tooManyReserves',
            "This patron has already placed reservesallowed holds, tooManyReserves should be raised"
        );
    };

    }
);
$biblio = $builder->build_sample_biblio({ itemtype => 'CANNOT' });
my $branch_rule_item = $builder->build_sample_item({ library => $branch_1, itype => 'CANNOT', biblionumber => $biblio->biblionumber});
is(CanItemBeReserved($patrons[0], $branch_rule_item)->{status}, 'notReservable',
    "CanItemBeReserved should return 'notReservable'");

t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
$branch_rule_item = $builder->build_sample_item({ library => $branch_2, itype => 'CAN', biblionumber => $biblio->biblionumber});
is(CanItemBeReserved($patrons[0], $branch_rule_item)->{status},
    'cannotReserveFromOtherBranches',
    "CanItemBeReserved should use PatronLibrary rule when ReservesControlBranch set to 'PatronLibrary'");
t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'ItemHomeLibrary' );
is(CanItemBeReserved($patrons[0], $branch_rule_item)->{status},
    'OK',
    "CanItemBeReserved should use item home library rule when ReservesControlBranch set to 'ItemsHomeLibrary'");

$branch_rule_item = $builder->build_sample_item({ library => $branch_1, itype => 'CAN', biblionumber => $biblio->biblionumber});
is(CanItemBeReserved($patrons[0], $branch_rule_item)->{status}, 'OK',
    "CanItemBeReserved should return 'OK'");

# Bug 12632

$dbh->do('DELETE FROM biblio');

$biblio = $builder->build_sample_biblio({ itemtype => 'ONLY1' });
my $limit_count_item = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber});

Koha::CirculationRules->set_rules(
    {

        }
    }
);
is( CanItemBeReserved( $patrons[0], $limit_count_item )->{status},
    'OK', 'Patron can reserve item with hold limit of 1, no holds placed' );

my $res_id = AddReserve(

    }
);

is( CanItemBeReserved( $patrons[0], $limit_count_item )->{status},
    'tooManyReserves', 'Patron cannot reserve item with hold limit of 1, 1 bib level hold placed' );
is( CanItemBeReserved( $patrons[0], $limit_count_item, undef, { ignore_hold_counts => 1 } )->{status},
    'OK', 'Patron can reserve item if checking policy but not counts' );

    #results should be the same for both ReservesControlBranch settings
t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'ItemHomeLibrary' );
is( CanItemBeReserved( $patrons[0], $limit_count_item )->{status},
    'tooManyReserves', 'Patron cannot reserve item with hold limit of 1, 1 bib level hold placed' );
#reset for further tests
t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );

    $dbh->do('DELETE FROM reserves');

    $biblio = $builder->build_sample_biblio;
    my $max_holds_item = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber});
    Koha::CirculationRules->set_rules(
        {
            categorycode => undef,

      Koha::Holds->search( { borrowernumber => $borrowernumbers[0] } )->count();
    is( $count, 3, 'Patron now has 3 holds' );

    my $ret = CanItemBeReserved( $patrons[0], $max_holds_item );
    is( $ret->{status}, 'OK', 'Patron can place hold with no borrower circ rules' );

    my $rule_all = Koha::CirculationRules->set_rule(

        }
    );

    $ret = CanItemBeReserved( $patrons[0], $max_holds_item );
    is( $ret->{status}, 'OK', 'Patron can place hold with branch/category rule of 5, category rule of 3' );

    $rule_branch->delete();

    $ret = CanItemBeReserved( $patrons[0], $max_holds_item );
    is( $ret->{status}, 'tooManyReserves', 'Patron cannot place hold with only a category rule of 3' );

    $rule_all->delete();
    $rule_branch->rule_value(3);
    $rule_branch->store();

    $ret = CanItemBeReserved( $patrons[0], $max_holds_item );
    is( $ret->{status}, 'tooManyReserves', 'Patron cannot place hold with only a branch/category rule of 3' );

    $rule_branch->rule_value(5);

    $rule_branch->rule_value(5);
    $rule_branch->store();

    $ret = CanItemBeReserved( $patrons[0], $max_holds_item );
    is( $ret->{status}, 'OK', 'Patron can place hold with branch/category rule of 5, category rule of 5' );
};


    plan tests => 4;

    $biblio = $builder->build_sample_biblio({ itemtype => 'ONLY1' });
    my $pickup_item = $builder->build_sample_item({ library => $branch_1, biblionumber => $biblio->biblionumber});
    #Add a default rule to allow some holds

    Koha::CirculationRules->set_rules(

            }
        }
    );
    my $item = Koha::Items->find($itemnumber);
    my $branch_to = $builder->build({ source => 'Branch' })->{ branchcode };
    my $library = Koha::Libraries->find($branch_to);
    $library->pickup_location('1')->store;
    my $patron = $builder->build_object({ class => 'Koha::Patrons' });

    t::lib::Mocks::mock_preference('UseBranchTransferLimits', 1);
    t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');

    $library->pickup_location('1')->store;
    is(CanItemBeReserved($patron, $pickup_item, $branch_to)->{status},
       'OK', 'Library is a pickup location');

    my $limit = Koha::Item::Transfer::Limit->new({
        fromBranch => $pickup_item->holdingbranch,
        toBranch => $branch_to,
        itemtype => $pickup_item->effective_itemtype,
    })->store;
    is(CanItemBeReserved($patron, $pickup_item, $branch_to)->{status},
       'cannotBeTransferred', 'Item cannot be transferred');
    $limit->delete;

    $library->pickup_location('0')->store;
    is(CanItemBeReserved($patron, $pickup_item, $branch_to)->{status},
       'libraryNotPickupLocation', 'Library is not a pickup location');
    is(CanItemBeReserved($patron, $pickup_item, 'nonexistent')->{status},
       'libraryNotFound', 'Cannot set unknown library as pickup location');
};



    # Create 3 biblios with items
    my $biblio_1 = $builder->build_sample_biblio({ itemtype => $itemtype->itemtype });
    my $item_1 = $builder->build_sample_item({ library => $library->branchcode, biblionumber => $biblio_1->biblionumber});
    my $biblio_2 = $builder->build_sample_biblio({ itemtype => $itemtype->itemtype });
    my $item_2 = $builder->build_sample_item({ library => $library->branchcode, biblionumber => $biblio_2->biblionumber});
    my $biblio_3 = $builder->build_sample_biblio({ itemtype => $itemtype->itemtype });
    my $item_3 = $builder->build_sample_item({ library => $library->branchcode, biblionumber => $biblio_3->biblionumber});

    Koha::CirculationRules->set_rules(
        {

    );

    is_deeply(
        CanItemBeReserved( $patron, $item_1 ),
        { status => 'OK' },
        'Patron can reserve item with hold limit of 1, no holds placed'
    );

    );

    is_deeply(
        CanItemBeReserved( $patron, $item_1 ),
        { status => 'tooManyReserves', limit => 1 },
        'Patron cannot reserve item with hold limit of 1, 1 bib level hold placed'
    );

    );

    is_deeply(
        CanItemBeReserved( $patron, $item_2 ),
        { status => 'OK' },
        'Patron can reserve item with 2 reserves daily cap'
    );

        }
    );
    is_deeply(
        CanItemBeReserved( $patron, $item_2 ),
        { status => 'tooManyReservesToday', limit => 2 },
        'Patron cannot a third item with 2 reserves daily cap'
    );

    $hold->reservedate($yesterday)->store;

    is_deeply(
        CanItemBeReserved( $patron, $item_2 ),
        { status => 'OK' },
        'Patron can reserve item with 2 bib level hold placed on different days, 2 reserves daily cap'
    );

    # Delete existing holds
    Koha::Holds->search->delete;
    is_deeply(
        CanItemBeReserved( $patron, $item_2 ),
        { status => 'tooManyReservesToday', limit => 0 },
        'Patron cannot reserve if holds_per_day is 0 (i.e. 0 is 0)'
    );


    Koha::Holds->search->delete;
    is_deeply(
        CanItemBeReserved( $patron, $item_2 ),
        { status => 'OK' },
        'Patron can reserve if holds_per_day is undef (i.e. undef is unlimited daily cap)'
    );

    );

    is_deeply(
        CanItemBeReserved( $patron, $item_3 ),
        { status => 'OK' },
        'Patron can reserve if holds_per_day is undef (i.e. undef is unlimited daily cap)'
    );

        }
    );
    is_deeply(
        CanItemBeReserved( $patron, $item_3 ),
        { status => 'tooManyReserves', limit => 3 },
        'Unlimited daily holds, but reached reservesallowed'
    );
    #results should be the same for both ReservesControlBranch settings
    t::lib::Mocks::mock_preference('ReservesControlBranch', 'ItemHomeLibrary');
    is_deeply(
        CanItemBeReserved( $patron, $item_3 ),
        { status => 'tooManyReserves', limit => 3 },
        'Unlimited daily holds, but reached reservesallowed'
    );


    # Test 1: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'OK' },
        'Patron can place hold if no circ_rules where defined'
    );


    # Test 2: Patron 1 can place hold
    is_deeply(
        CanItemBeReserved( $patron1, $item_2 ),
        { status => 'OK' },
        'Patron can place hold because patron\'s home library is part of hold group'
    );

    # Test 3: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'branchNotInHoldGroup' },
        'Patron cannot place hold because patron\'s home library is not part of hold group'
    );


    # Test 4: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'OK' },
        'Patron can place hold if holdallowed is set to "any" for library 2'
    );


    # Test 5: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'branchNotInHoldGroup' },
        'Patron cannot place hold if holdallowed is set to "hold group" for library 2'
    );


    # Test 6: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'OK' },
        'Patron can place hold if holdallowed is set to "any" for itemtype 2'
    );


    # Test 7: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'branchNotInHoldGroup' },
        'Patron cannot place hold if holdallowed is set to "hold group" for itemtype 2'
    );


    # Test 8: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'OK' },
        'Patron can place hold if holdallowed is set to "any" for itemtype 2 and library 2'
    );


    # Test 9: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2 ),
        { status => 'branchNotInHoldGroup' },
        'Patron cannot place hold if holdallowed is set to "hold group" for itemtype 2 and library 2'
    );


    # Test 1: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'OK' },
        'Patron can place hold if no circ_rules where defined'
    );


    # Test 2: Patron 1 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library1->branchcode ),
        { status => 'OK' },
        'Patron can place hold because pickup location is part of hold group'
    );

    # Test 3: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'pickupNotInHoldGroup' },
        'Patron cannot place hold because pickup location is not part of hold group'
    );


    # Test 4: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'OK' },
        'Patron can place hold if default_branch_circ_rules is set to "any" for library 2'
    );


    # Test 5: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'pickupNotInHoldGroup' },
        'Patron cannot place hold if hold_fulfillment_policy is set to "hold group" for library 2'
    );


    # Test 6: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'OK' },
        'Patron can place hold if hold_fulfillment_policy is set to "any" for itemtype 2'
    );


    # Test 7: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'pickupNotInHoldGroup' },
        'Patron cannot place hold if hold_fulfillment_policy is set to "hold group" for itemtype 2'
    );


    # Test 8: Patron 3 can place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'OK' },
        'Patron can place hold if hold_fulfillment_policy is set to "any" for itemtype 2 and library 2'
    );


    # Test 9: Patron 3 cannot place hold
    is_deeply(
        CanItemBeReserved( $patron3, $item_2, $library3->branchcode ),
        { status => 'pickupNotInHoldGroup' },
        'Patron cannot place hold if hold_fulfillment_policy is set to "hold group" for itemtype 2 and library 2'
    );

        }
    );
    is_deeply(
        CanItemBeReserved( $patron, $item, $library->branchcode ),
        { status => 'OK' },
        'Patron of specified category can place 1 hold on specified itemtype'
    );

        borrowernumber => $patron->borrowernumber,
    }});
    is_deeply(
        CanItemBeReserved( $patron, $item, $library->branchcode ),
        { status => 'tooManyReserves', limit => 1 },
        'Patron of specified category can place 1 hold on specified itemtype, cannot place a second'
    );

        }
    );
    is_deeply(
        CanItemBeReserved( $patron, $item, $library->branchcode ),
        { status => 'OK' },
        'Patron of specified category can place 1 hold on specified itemtype if library rule for all types and categories set to 2'
    );




       'alreadypossession',
       'Patron cannot place hold on a book loaned to itself');

    is(C4::Reserves::CanItemBeReserved( $patron, $item )->{status},
                                       $item->itemnumber)->{status},
       'alreadypossession',
       'Patron cannot place hold on an item loaned to itself');


       'OK',
       'Patron can place hold on a book loaned to itself');

    is(C4::Reserves::CanItemBeReserved( $patron, $item )->{status},
                                       $item->itemnumber)->{status},
       'OK',
       'Patron can place hold on an item loaned to itself');
};
- 

Return to bug 29562

Lines 1166-1172 sub CanBookBeIssued { Link Here

(-)a/C4/Circulation.pm (-12 / +11 lines)
1166		1166
1167	## check for high holds decreasing loan period	1167	## check for high holds decreasing loan period
1168	if ( C4::Context->preference('decreaseLoanHighHolds') ) {	1168	if ( C4::Context->preference('decreaseLoanHighHolds') ) {
1169	my $check = checkHighHolds( $item_unblessed, $patron_unblessed );	1169	my $check = checkHighHolds( $item_object, $patron );
1170		1170
1171	if ( $check->{exceeded} ) {	1171	if ( $check->{exceeded} ) {
1172	if ($override_high_holds) {	1172	if ($override_high_holds) {
Lines 1278-1286 sub CanBookBeReturned { Link Here
1278	=cut	1278	=cut
1279		1279
1280	sub checkHighHolds {	1280	sub checkHighHolds {
1281	my ( $item, $borrower ) = @_;	1281	my ( $item, $patron ) = @_;
1282	my $branchcode = _GetCircControlBranch( $item, $borrower );	1282	my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );
1283	my $item_object = Koha::Items->find( $item->{itemnumber} );
1284		1283
1285	my $return_data = {	1284	my $return_data = {
1286	exceeded => 0,	1285	exceeded => 0,
Lines 1289-1295 sub checkHighHolds { Link Here
1289	due_date => undef,	1288	due_date => undef,
1290	};	1289	};
1291		1290
1292	my $holds = Koha::Holds->search( { biblionumber => $item->{'biblionumber'} } );	1291	my $holds = Koha::Holds->search( { biblionumber => $item->biblionumber } );
1293		1292
1294	if ( $holds->count() ) {	1293	if ( $holds->count() ) {
1295	$return_data->{outstanding} = $holds->count();	1294	$return_data->{outstanding} = $holds->count();
Lines 1322-1328 sub checkHighHolds { Link Here
1322	}	1321	}
1323		1322
1324	# Remove any items that are not holdable for this patron	1323	# Remove any items that are not holdable for this patron
1325	@items = grep { CanItemBeReserved( $borrower->{borrowernumber}, $_->itemnumber, undef, { ignore_found_holds => 1 } )->{status} eq 'OK' } @items;	1324	@items = grep { CanItemBeReserved( $patron , $_, undef, { ignore_found_holds => 1 } )->{status} eq 'OK' } @items;
1326		1325
1327	my $items_count = scalar @items;	1326	my $items_count = scalar @items;
1328		1327
Lines 1337-1358 sub checkHighHolds { Link Here
1337		1336
1338	my $issuedate = dt_from_string();	1337	my $issuedate = dt_from_string();
1339		1338
1340	my $itype = $item_object->effective_itemtype;	1339	my $itype = $item->effective_itemtype;
1341	my $daysmode = Koha::CirculationRules->get_effective_daysmode(	1340	my $daysmode = Koha::CirculationRules->get_effective_daysmode(
1342	{	1341	{
1343	categorycode => $borrower->{categorycode},	1342	categorycode => $patron->categorycode,
1344	itemtype => $itype,	1343	itemtype => $itype,
1345	branchcode => $branchcode,	1344	branchcode => $branchcode,
1346	}	1345	}
1347	);	1346	);
1348	my $calendar = Koha::Calendar->new( branchcode => $branchcode, days_mode => $daysmode );	1347	my $calendar = Koha::Calendar->new( branchcode => $branchcode, days_mode => $daysmode );
1349		1348
1350	my $orig_due = C4::Circulation::CalcDateDue( $issuedate, $itype, $branchcode, $borrower );	1349	my $orig_due = C4::Circulation::CalcDateDue( $issuedate, $itype, $branchcode, $patron->unblessed );
1351		1350
1352	my $rule = Koha::CirculationRules->get_effective_rule(	1351	my $rule = Koha::CirculationRules->get_effective_rule(
1353	{	1352	{
1354	categorycode => $borrower->{categorycode},	1353	categorycode => $patron->categorycode,
1355	itemtype => $item_object->effective_itemtype,	1354	itemtype => $item->effective_itemtype,
1356	branchcode => $branchcode,	1355	branchcode => $branchcode,
1357	rule_name => 'decreaseloanholds',	1356	rule_name => 'decreaseloanholds',
1358	}	1357	}
Lines 2846-2852 sub CanBookBeRenewed { Link Here
2846	next if IsItemOnHoldAndFound( $item->itemnumber );	2845	next if IsItemOnHoldAndFound( $item->itemnumber );
2847	while ( my $patron = $patrons->next ) {	2846	while ( my $patron = $patrons->next ) {
2848	next unless IsAvailableForItemLevelRequest($item, $patron);	2847	next unless IsAvailableForItemLevelRequest($item, $patron);
2849	next unless CanItemBeReserved($patron->borrowernumber,$item->itemnumber,undef,{ignore_hold_counts=>1})->{status} eq 'OK';	2848	next unless CanItemBeReserved($patron,$item,undef,{ignore_hold_counts=>1})->{status} eq 'OK';
2850	push @reservable, $item->itemnumber;	2849	push @reservable, $item->itemnumber;
2851	if (@reservable >= @borrowernumbers) {	2850	if (@reservable >= @borrowernumbers) {
2852	$resfound = 0;	2851	$resfound = 0;

Lines 330-345 sub CanBookBeReserved{ Link Here

(-)a/C4/Reserves.pm (-21 / +27 lines)
330	return { status =>'alreadypossession' };	330	return { status =>'alreadypossession' };
331	}	331	}
332		332
333	my @itemnumbers = Koha::Items->search({ biblionumber => $biblionumber})->get_column("itemnumber");	333	my $items;
334	#get items linked via host records	334	#get items linked via host records
335	my @hostitems = get_hostitemnumbers_of($biblionumber);	335	my @hostitemnumbers = get_hostitemnumbers_of($biblionumber);
336	if (@hostitems){	336	if (@hostitemnumbers){
337	push (@itemnumbers, @hostitems);	337	$items = Koha::Items->search({
		338	-or => [
		339	biblionumber => $biblionumber,
		340	itemnumber => { -in => @hostitemnumbers }
		341	]
		342	});
		343	} else {
		344	$items = Koha::Items->search({ biblionumber => $biblionumber});
338	}	345	}
339		346
340	my $canReserve = { status => '' };	347	my $canReserve = { status => '' };
341	foreach my $itemnumber (@itemnumbers) {	348	my $patron = Koha::Patrons->find( $borrowernumber );
342	$canReserve = CanItemBeReserved( $borrowernumber, $itemnumber, $pickup_branchcode, $params );	349	while ( my $item = $items->next ) {
		350	$canReserve = CanItemBeReserved( $patron, $item, $pickup_branchcode, $params );
343	return { status => 'OK' } if $canReserve->{status} eq 'OK';	351	return { status => 'OK' } if $canReserve->{status} eq 'OK';
344	}	352	}
345	return $canReserve;	353	return $canReserve;
Lines 347-353 sub CanBookBeReserved{ Link Here
347		355
348	=head2 CanItemBeReserved	356	=head2 CanItemBeReserved
349		357
350	$canReserve = &CanItemBeReserved($borrowernumber, $itemnumber, $branchcode, $params)	358	$canReserve = &CanItemBeReserved($patron, $item, $branchcode, $params)
351	if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }	359	if ($canReserve->{status} eq 'OK') { #We can reserve this Item! }
352		360
353	current params are:	361	current params are:
Lines 372-378 sub CanBookBeReserved{ Link Here
372	=cut	380	=cut
373		381
374	sub CanItemBeReserved {	382	sub CanItemBeReserved {
375	my ( $borrowernumber, $itemnumber, $pickup_branchcode, $params ) = @_;	383	my ( $patron, $item, $pickup_branchcode, $params ) = @_;
376		384
377	my $dbh = C4::Context->dbh;	385	my $dbh = C4::Context->dbh;
378	my $ruleitemtype; # itemtype of the matching issuing rule	386	my $ruleitemtype; # itemtype of the matching issuing rule
Lines 380-388 sub CanItemBeReserved { Link Here
380		388
381	# we retrieve borrowers and items informations #	389	# we retrieve borrowers and items informations #
382	# item->{itype} will come for biblioitems if necessery	390	# item->{itype} will come for biblioitems if necessery
383	my $item = Koha::Items->find($itemnumber);
384	my $biblio = $item->biblio;	391	my $biblio = $item->biblio;
385	my $patron = Koha::Patrons->find( $borrowernumber );
386	my $borrower = $patron->unblessed;	392	my $borrower = $patron->unblessed;
387		393
388	# If an item is damaged and we don't allow holds on damaged items, we can stop right here	394	# If an item is damaged and we don't allow holds on damaged items, we can stop right here
Lines 397-403 sub CanItemBeReserved { Link Here
397		403
398	# Check that the patron doesn't have an item level hold on this item already	404	# Check that the patron doesn't have an item level hold on this item already
399	return { status =>'itemAlreadyOnHold' }	405	return { status =>'itemAlreadyOnHold' }
400	if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $borrowernumber, itemnumber => $itemnumber } )->count() );	406	if ( !$params->{ignore_hold_counts} && Koha::Holds->search( { borrowernumber => $patron->borrowernumber, itemnumber => $item->itemnumber } )->count() );
401		407
402	# Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)	408	# Check that patron have not checked out this biblio (if AllowHoldsOnPatronsPossessions set)
403	if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')	409	if ( !C4::Context->preference('AllowHoldsOnPatronsPossessions')
Lines 454-460 sub CanItemBeReserved { Link Here
454	my $holds_per_day = $rights->{holds_per_day};	460	my $holds_per_day = $rights->{holds_per_day};
455		461
456	my $search_params = {	462	my $search_params = {
457	borrowernumber => $borrowernumber,	463	borrowernumber => $patron->borrowernumber,
458	biblionumber => $item->biblionumber,	464	biblionumber => $item->biblionumber,
459	};	465	};
460	$search_params->{found} = undef if $params->{ignore_found_holds};	466	$search_params->{found} = undef if $params->{ignore_found_holds};
Lines 470-476 sub CanItemBeReserved { Link Here
470	}	476	}
471		477
472	my $today_holds = Koha::Holds->search({	478	my $today_holds = Koha::Holds->search({
473	borrowernumber => $borrowernumber,	479	borrowernumber => $patron->borrowernumber,
474	reservedate => dt_from_string->date	480	reservedate => dt_from_string->date
475	});	481	});
476		482
Lines 495-504 sub CanItemBeReserved { Link Here
495	my $sthcount = $dbh->prepare($querycount);	501	my $sthcount = $dbh->prepare($querycount);
496		502
497	if ( defined $ruleitemtype ) {	503	if ( defined $ruleitemtype ) {
498	$sthcount->execute( $borrowernumber, $branchcode, $ruleitemtype );	504	$sthcount->execute( $patron->borrowernumber, $branchcode, $ruleitemtype );
499	}	505	}
500	else {	506	else {
501	$sthcount->execute( $borrowernumber, $branchcode );	507	$sthcount->execute( $patron->borrowernumber, $branchcode );
502	}	508	}
503		509
504	my $reservecount = "0";	510	my $reservecount = "0";
Lines 519-525 sub CanItemBeReserved { Link Here
519	# Now we need to check hold limits by patron category	525	# Now we need to check hold limits by patron category
520	my $rule = Koha::CirculationRules->get_effective_rule(	526	my $rule = Koha::CirculationRules->get_effective_rule(
521	{	527	{
522	categorycode => $borrower->{categorycode},	528	categorycode => $patron->categorycode,
523	branchcode => $branchcode,	529	branchcode => $branchcode,
524	rule_name => 'max_holds',	530	rule_name => 'max_holds',
525	}	531	}
Lines 527-533 sub CanItemBeReserved { Link Here
527	if (!$params->{ignore_hold_counts} && $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {	533	if (!$params->{ignore_hold_counts} && $rule && defined( $rule->rule_value ) && $rule->rule_value ne '' ) {
528	my $total_holds_count = Koha::Holds->search(	534	my $total_holds_count = Koha::Holds->search(
529	{	535	{
530	borrowernumber => $borrower->{borrowernumber}	536	borrowernumber => $patron->borrowernumber
531	}	537	}
532	)->count();	538	)->count();
533		539
Lines 535-541 sub CanItemBeReserved { Link Here
535	}	541	}
536		542
537	my $reserves_control_branch =	543	my $reserves_control_branch =
538	GetReservesControlBranch( $item->unblessed(), $borrower );	544	GetReservesControlBranch( $item->unblessed(), $patron->unblessed );
539	my $branchitemrule =	545	my $branchitemrule =
540	C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->effective_itemtype );	546	C4::Circulation::GetBranchItemRule( $reserves_control_branch, $item->effective_itemtype );
541		547
Lines 551-557 sub CanItemBeReserved { Link Here
551		557
552	my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );	558	my $item_library = Koha::Libraries->find( {branchcode => $item->homebranch} );
553	if ( $branchitemrule->{holdallowed} eq 'from_local_hold_group') {	559	if ( $branchitemrule->{holdallowed} eq 'from_local_hold_group') {
554	if($borrower->{branchcode} ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $borrower->{branchcode}} )) {	560	if($patron->branchcode ne $item->homebranch && !$item_library->validate_hold_sibling( {branchcode => $patron->branchcode} )) {
555	return { status => 'branchNotInHoldGroup' };	561	return { status => 'branchNotInHoldGroup' };
556	}	562	}
557	}	563	}
Lines 561-567 sub CanItemBeReserved { Link Here
561	if ( C4::Context->preference('IndependentBranches')	567	if ( C4::Context->preference('IndependentBranches')
562	and !C4::Context->preference('canreservefromotherbranches') )	568	and !C4::Context->preference('canreservefromotherbranches') )
563	{	569	{
564	if ( $item->homebranch ne $borrower->{branchcode} ) {	570	if ( $item->homebranch ne $patron->branchcode ) {
565	return { status => 'cannotReserveFromOtherBranches' };	571	return { status => 'cannotReserveFromOtherBranches' };
566	}	572	}
567	}	573	}
Lines 1423-1429 sub ItemsAnyAvailableAndNotRestricted { Link Here
1423	\|\| Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan	1429	\|\| Koha::ItemTypes->find( $i->effective_itemtype() )->notforloan
1424	\|\| $branchitemrule->{holdallowed} eq 'from_home_library' && $param->{patron}->branchcode ne $i->homebranch	1430	\|\| $branchitemrule->{holdallowed} eq 'from_home_library' && $param->{patron}->branchcode ne $i->homebranch
1425	\|\| $branchitemrule->{holdallowed} eq 'from_local_hold_group' && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } )	1431	\|\| $branchitemrule->{holdallowed} eq 'from_local_hold_group' && ! $item_library->validate_hold_sibling( { branchcode => $param->{patron}->branchcode } )
1426	\|\| CanItemBeReserved( $param->{patron}->borrowernumber, $i->id )->{status} ne 'OK';	1432	\|\| CanItemBeReserved( $param->{patron}, $i )->{status} ne 'OK';
1427	}	1433	}
1428		1434
1429	return 0;	1435	return 0;

Lines 237-245 if ( $query->param('place_reserve') ) { Link Here

(-)a/opac/opac-reserve.pl (-6 / +6 lines)
237	$branch = $patron->branchcode;	237	$branch = $patron->branchcode;
238	}	238	}
239		239
		240	my $item = $itemNum ? Koha::Items->find( $itemNum ) : undef;
240	# When choosing a specific item, the default pickup library should be dictated by the default hold policy	241	# When choosing a specific item, the default pickup library should be dictated by the default hold policy
241	if ( ! C4::Context->preference("OPACAllowUserToChooseBranch") && $itemNum ) {	242	if ( ! C4::Context->preference("OPACAllowUserToChooseBranch") && $itemNum ) {
242	my $item = Koha::Items->find( $itemNum );
243	my $type = $item->effective_itemtype;	243	my $type = $item->effective_itemtype;
244	my $rule = GetBranchItemRule( $patron->branchcode, $type );	244	my $rule = GetBranchItemRule( $patron->branchcode, $type );
245		245
Lines 254-261 if ( $query->param('place_reserve') ) { Link Here
254	}	254	}
255		255
256	#item may belong to a host biblio, if yes change biblioNum to hosts bilbionumber	256	#item may belong to a host biblio, if yes change biblioNum to hosts bilbionumber
257	if ( $itemNum ne '' ) {	257	if ( $itemNum ) {
258	my $item = Koha::Items->find( $itemNum );
259	my $hostbiblioNum = $item->biblio->biblionumber;	258	my $hostbiblioNum = $item->biblio->biblionumber;
260	if ( $hostbiblioNum ne $biblioNum ) {	259	if ( $hostbiblioNum ne $biblioNum ) {
261	$biblioNum = $hostbiblioNum;	260	$biblioNum = $hostbiblioNum;
Lines 276-283 if ( $query->param('place_reserve') ) { Link Here
276	my $expiration_date = $query->param("expiration_date_$biblioNum");	275	my $expiration_date = $query->param("expiration_date_$biblioNum");
277		276
278	my $rank = $biblioData->{rank};	277	my $rank = $biblioData->{rank};
279	if ( $itemNum ne '' ) {	278	my $patron = Koha::Patrons->find( $borrowernumber );
280	$canreserve = 1 if CanItemBeReserved( $borrowernumber, $itemNum, $branch )->{status} eq 'OK';	279	if ( $itemNum ) {
		280	$canreserve = 1 if CanItemBeReserved( $patron, $item, $branch )->{status} eq 'OK';
281	}	281	}
282	else {	282	else {
283	$canreserve = 1 if CanBookBeReserved( $borrowernumber, $biblioNum, $branch )->{status} eq 'OK';	283	$canreserve = 1 if CanBookBeReserved( $borrowernumber, $biblioNum, $branch )->{status} eq 'OK';
Lines 559-565 foreach my $biblioNum (@biblionumbers) { Link Here
559	my $policy_holdallowed = !$itemLoopIter->{already_reserved};	559	my $policy_holdallowed = !$itemLoopIter->{already_reserved};
560	$policy_holdallowed &&=	560	$policy_holdallowed &&=
561	IsAvailableForItemLevelRequest($item, $patron) &&	561	IsAvailableForItemLevelRequest($item, $patron) &&
562	CanItemBeReserved( $borrowernumber, $itemNum )->{status} eq 'OK';	562	CanItemBeReserved( $patron, $item )->{status} eq 'OK';
563		563
564	if ($policy_holdallowed) {	564	if ($policy_holdallowed) {
565	my $opac_hold_policy = Koha::CirculationRules->get_opacitemholds_policy( { item => $item, patron => $patron } );	565	my $opac_hold_policy = Koha::CirculationRules->get_opacitemholds_policy( { item => $item, patron => $patron } );

Lines 1239-1246 subtest 'AllowHoldOnPatronPossession test' => sub { Link Here

(-)a/t/db_dependent/Reserves.t (-5 / +2 lines)
1239	'alreadypossession',	1239	'alreadypossession',
1240	'Patron cannot place hold on a book loaned to itself');	1240	'Patron cannot place hold on a book loaned to itself');
1241		1241
1242	is(C4::Reserves::CanItemBeReserved($patron->borrowernumber,	1242	is(C4::Reserves::CanItemBeReserved( $patron, $item )->{status},
1243	$item->itemnumber)->{status},
1244	'alreadypossession',	1243	'alreadypossession',
1245	'Patron cannot place hold on an item loaned to itself');	1244	'Patron cannot place hold on an item loaned to itself');
1246		1245
Lines 1251-1258 subtest 'AllowHoldOnPatronPossession test' => sub { Link Here
1251	'OK',	1250	'OK',
1252	'Patron can place hold on a book loaned to itself');	1251	'Patron can place hold on a book loaned to itself');
1253		1252
1254	is(C4::Reserves::CanItemBeReserved($patron->borrowernumber,	1253	is(C4::Reserves::CanItemBeReserved( $patron, $item )->{status},
1255	$item->itemnumber)->{status},
1256	'OK',	1254	'OK',
1257	'Patron can place hold on an item loaned to itself');	1255	'Patron can place hold on an item loaned to itself');
1258	};	1256	};
1259	-

Lines 49-56 my $expirationdate = $input->param('expiration_date'); Link Here

(-)a/reserve/placerequest.pl (-9 / +8 lines)
49	my $itemtype = $input->param('itemtype') \|\| undef;	49	my $itemtype = $input->param('itemtype') \|\| undef;
50	my $non_priority = $input->param('non_priority');	50	my $non_priority = $input->param('non_priority');
51		51
52	my $borrower = Koha::Patrons->find( $borrowernumber );	52	my $patron = Koha::Patrons->find( $borrowernumber );
53	$borrower = $borrower->unblessed if $borrower;
54		53
55	my $biblionumbers = $input->param('biblionumbers');	54	my $biblionumbers = $input->param('biblionumbers');
56	$biblionumbers \|\|= $biblionumber . '/';	55	$biblionumbers \|\|= $biblionumber . '/';
Lines 70-76 foreach my $bibnum (@biblionumbers) { Link Here
70		69
71	my $found;	70	my $found;
72		71
73	if ( $type eq 'str8' && $borrower ) {	72	if ( $type eq 'str8' && $patron ) {
74		73
75	foreach my $biblionumber ( keys %bibinfos ) {	74	foreach my $biblionumber ( keys %bibinfos ) {
76	my $count = @bibitems;	75	my $count = @bibitems;
Lines 97-109 if ( $type eq 'str8' && $borrower ) { Link Here
97	$biblionumber = $item->biblionumber;	96	$biblionumber = $item->biblionumber;
98	}	97	}
99		98
100	my $can_item_be_reserved = CanItemBeReserved($borrower->{'borrowernumber'}, $item->itemnumber, $item_pickup_location)->{status};	99	my $can_item_be_reserved = CanItemBeReserved($patron, $item, $item_pickup_location)->{status};
101		100
102	if ( $can_item_be_reserved eq 'OK' \|\| ( $can_item_be_reserved ne 'itemAlreadyOnHold' && $can_override ) ) {	101	if ( $can_item_be_reserved eq 'OK' \|\| ( $can_item_be_reserved ne 'itemAlreadyOnHold' && $can_override ) ) {
103	AddReserve(	102	AddReserve(
104	{	103	{
105	branchcode => $item_pickup_location,	104	branchcode => $item_pickup_location,
106	borrowernumber => $borrower->{'borrowernumber'},	105	borrowernumber => $patron->borrowernumber,
107	biblionumber => $biblionumber,	106	biblionumber => $biblionumber,
108	priority => $rank[0],	107	priority => $rank[0],
109	reservation_date => $startdate,	108	reservation_date => $startdate,
Lines 121-131 if ( $type eq 'str8' && $borrower ) { Link Here
121		120
122	} elsif (@biblionumbers > 1) {	121	} elsif (@biblionumbers > 1) {
123	my $bibinfo = $bibinfos{$biblionumber};	122	my $bibinfo = $bibinfos{$biblionumber};
124	if ( $can_override \|\| CanBookBeReserved($borrower->{'borrowernumber'}, $biblionumber)->{status} eq 'OK' ) {	123	if ( $can_override \|\| CanBookBeReserved($patron->borrowernumber, $biblionumber)->{status} eq 'OK' ) {
125	AddReserve(	124	AddReserve(
126	{	125	{
127	branchcode => $bibinfo->{pickup},	126	branchcode => $bibinfo->{pickup},
128	borrowernumber => $borrower->{'borrowernumber'},	127	borrowernumber => $patron->borrowernumber,
129	biblionumber => $biblionumber,	128	biblionumber => $biblionumber,
130	priority => $bibinfo->{rank},	129	priority => $bibinfo->{rank},
131	reservation_date => $startdate,	130	reservation_date => $startdate,
Lines 142-152 if ( $type eq 'str8' && $borrower ) { Link Here
142	} else {	141	} else {
143	# place a request on 1st available	142	# place a request on 1st available
144	for ( my $i = 0 ; $i < $holds_to_place_count ; $i++ ) {	143	for ( my $i = 0 ; $i < $holds_to_place_count ; $i++ ) {
145	if ( $can_override \|\| CanBookBeReserved($borrower->{'borrowernumber'}, $biblionumber)->{status} eq 'OK' ) {	144	if ( $can_override \|\| CanBookBeReserved($patron->borrowernumber, $biblionumber)->{status} eq 'OK' ) {
146	AddReserve(	145	AddReserve(
147	{	146	{
148	branchcode => $branch,	147	branchcode => $branch,
149	borrowernumber => $borrower->{'borrowernumber'},	148	borrowernumber => $patron->borrowernumber,
150	biblionumber => $biblionumber,	149	biblionumber => $biblionumber,
151	priority => $rank[0],	150	priority => $rank[0],
152	reservation_date => $startdate,	151	reservation_date => $startdate,