=item C<RecallPlacedAtHoldingBranch>

A recall for this item was found, and the transfer has already been completed as the item's branch matches the recall's pickup branch.

=item C<RecallFound>

A recall for this item was found, and the item needs to be transferred to the recall's pickup branch.

    # find recall

    my $recall = Koha::Recalls->find({ itemnumber => $itemnumber, status => 'T' });

    if ( defined $recall and C4::Context->preference('UseRecalls') ) {

        # do a transfer if the recall branch is different to the item holding branch

        if ( $recall->branchcode eq $fbr ) {

            $dotransfer = 0;

            $messages->{'RecallPlacedAtHoldingBranch'} = 1;

        } else {

            $dotransfer = 1;

            $messages->{'RecallFound'} = $recall;

        }

    }

=head3 RECALLED

recalled by someone else

          * RECALL PLACED ?

              - fill recall if recall to this patron

              - cancel recall or not

              - revert recall's waiting status or not

    my $cancel_recall = $params && $params->{cancel_recall};

    my $recall_id = $params && $params->{recall_id};

            Koha::Recalls->move_recall({ action => $cancel_recall, recall_id => $recall_id, itemnumber => $item_object->itemnumber, borrowernumber => $borrower->{borrowernumber} }) if C4::Context->preference('UseRecalls');

=item C<RecallFound>

This item can fill a recall. The recall object is returned. If the recall pickup branch differs from

the branch this item is being returned at, C<RecallNeedsTransfer> is also returned which contains this

branchcode.

=item C<TransferredRecall>

This item has been transferred to this branch to fill a recall. The recall object is returned.

    # find recalls...

    # check if this item is recallable first, which includes checking if UseRecalls syspref is enabled

    my $recall = undef;

    $recall = $item->check_recalls if $item->can_be_waiting_recall;

    if ( defined $recall ) {

        $messages->{RecallFound} = $recall;

        if ( $recall->branchcode ne $branch ) {

            $messages->{RecallNeedsTransfer} = $branch;

        }

    }

    my $transfer_recall = Koha::Recalls->find({ itemnumber => $item->itemnumber, status => 'T' }); # all recalls that have triggered a transfer will have an allocated itemnumber

    if ( $transfer_recall and

         $transfer_recall->branchcode eq $branch and

         C4::Context->preference('UseRecalls') ) {

        $messages->{TransferredRecall} = $transfer_recall;

    }

    my $recall = undef;

    $recall = $item->check_recalls if $item->can_be_waiting_recall;

    if ( defined $recall ) {

        if ( $recall->item_level_recall ) {

            # item-level recall. check if this item is the recalled item, otherwise renewal will be allowed

            return ( 0, 'recalled' ) if ( $recall->itemnumber == $item->itemnumber );

        } else {

            # biblio-level recall, so only disallow renewal if the biblio-level recall has been fulfilled by a different item

            return ( 0, 'recalled' ) unless ( $recall->waiting );

        }

    }

         { status => recall }, if the borrower has already placed a recall on this item

    # check if a recall exists on this item from this borrower

    return { status => 'recall' }

      if Koha::Recalls->search({ borrowernumber => $borrowernumber, itemnumber => $itemnumber, old => undef })->count;

        my $item_recalled_count   = 0;

                # is item a waiting recall?

                my $recallstatus = '';

                    $recallstatus = 'Waiting' if Koha::Recalls->search({ itemnumber => $item->{itemnumber}, status => 'W' })->count;

                    || $recallstatus eq 'Waiting'

                    $item_recalled_count++   if $recallstatus eq 'Waiting';

                    $other_items->{$key}->{recalled} = ($recallstatus) ? 1 : 0;

        $oldbiblio->{recalledcount}        = $item_recalled_count;

=head3 recalls

    my @recalls = $biblio->recalls;

Return all active recalls attached to this biblio, sorted by oldest first

=cut

sub recalls {

    my ( $self ) = @_;

    my @recalls_rs = Koha::Recalls->search({ biblionumber => $self->biblionumber, old => undef }, { order_by => { -asc => 'recalldate' } });

    return @recalls_rs;

}

=head3 can_be_recalled

    my @items_for_recall = $biblio->can_be_recalled({ patron => $patron_object });

Does biblio-level checks and returns the items attached to this biblio that are available for recall

=cut

sub can_be_recalled {

    my ( $self, $params ) = @_;

    return 0 if !( C4::Context->preference('UseRecalls') );

    my $patron = $params->{patron};

    my $branchcode = C4::Context->userenv->{'branch'};

    if ( C4::Context->preference('CircControl') eq 'PatronLibrary' and $patron ) {

        $branchcode = $patron->branchcode;

    }

    my @all_items = Koha::Items->search({ biblionumber => $self->biblionumber });

    # if there are no available items at all, no recall can be placed

    return 0 if ( scalar @all_items == 0 );

    my @itemtypes;

    my @itemnumbers;

    my @items;

    foreach my $item ( @all_items ) {

        if ( $item->can_be_recalled({ patron => $patron }) ) {

            push( @itemtypes, $item->effective_itemtype );

            push( @itemnumbers, $item->itemnumber );

            push( @items, $item );

        }

    }

    # if there are no recallable items, no recall can be placed

    return 0 if ( scalar @items == 0 );

    # Check the circulation rule for each relevant itemtype for this biblio

    my ( @recalls_allowed, @recalls_per_record, @on_shelf_recalls );

    foreach my $itemtype ( @itemtypes ) {

        my $rule = Koha::CirculationRules->get_effective_rules({

            branchcode => $branchcode,

            categorycode => $patron ? $patron->categorycode : undef,

            itemtype => $itemtype,

            rules => [

                'recalls_allowed',

                'recalls_per_record',

                'on_shelf_recalls',

            ],

        });

        push( @recalls_allowed, $rule->{recalls_allowed} ) if $rule;

        push( @recalls_per_record, $rule->{recalls_per_record} ) if $rule;

        push( @on_shelf_recalls, $rule->{on_shelf_recalls} ) if $rule;

    }

    my $recalls_allowed = (sort {$b <=> $a} @recalls_allowed)[0]; # take highest

    my $recalls_per_record = (sort {$b <=> $a} @recalls_per_record)[0]; # take highest

    my %on_shelf_recalls_count = ();

    foreach my $count ( @on_shelf_recalls ) {

        $on_shelf_recalls_count{$count}++;

    }

    my $on_shelf_recalls = (sort {$on_shelf_recalls_count{$b} <=> $on_shelf_recalls_count{$a}} @on_shelf_recalls)[0]; # take most common

    # check recalls allowed has been set and is not zero

    return 0 if ( !defined($recalls_allowed) || $recalls_allowed == 0 );

    if ( $patron ) {

        # check borrower has not reached open recalls allowed limit

        return 0 if ( $patron->recalls->count >= $recalls_allowed );

        # check borrower has not reached open recalls allowed per record limit

        return 0 if ( $patron->recalls({ biblionumber => $self->biblionumber })->count >= $recalls_per_record );

        # check if any of the items under this biblio are already checked out by this borrower

        return 0 if ( Koha::Checkouts->search({ itemnumber => [ @itemnumbers ], borrowernumber => $patron->borrowernumber })->count > 0 );

    }

    # check item availability

    my $checked_out_count = 0;

    foreach (@items) {

        if ( Koha::Checkouts->search({ itemnumber => $_->itemnumber })->count > 0 ){ $checked_out_count++; }

    }

    # can't recall if on shelf recalls only allowed when all unavailable, but items are still available for checkout

    return 0 if ( $on_shelf_recalls eq 'all' && $checked_out_count < scalar @items );

    # can't recall if no items have been checked out

    return 0 if ( $checked_out_count == 0 );

    # can recall

    return @items;

}

=head3 recall

    my $recall = $item->recall;

Return the relevant recall for this item

=cut

sub recall {

    my ( $self ) = @_;

    my @recalls = Koha::Recalls->search({ biblionumber => $self->biblionumber, old => undef }, { order_by => { -asc => 'recalldate' } });

    foreach my $recall (@recalls) {

        if ( $recall->item_level_recall and $recall->itemnumber == $self->itemnumber ){

            return $recall;

        }

    }

    # no item-level recall to return, so return earliest biblio-level

    # FIXME: eventually this will be based on priority

    return $recalls[0];

}

=head3 can_be_recalled

    if ( $item->can_be_recalled({ patron => $patron_object }) ) # do recall

Does item-level checks and returns if items can be recalled by this borrower

=cut

sub can_be_recalled {

    my ( $self, $params ) = @_;

    return 0 if !( C4::Context->preference('UseRecalls') );

    # check if this item is not for loan, withdrawn or lost

    return 0 if ( $self->notforloan != 0 );

    return 0 if ( $self->itemlost != 0 );

    return 0 if ( $self->withdrawn != 0 );

    # check if this item is not checked out - if not checked out, can't be recalled

    return 0 if ( !defined( $self->checkout ) );

    my $patron = $params->{patron};

    my $branchcode = C4::Context->userenv->{'branch'};

    if ( $patron ) {

        $branchcode = C4::Circulation::_GetCircControlBranch( $self->unblessed, $patron->unblessed );

    }

    # Check the circulation rule for each relevant itemtype for this item

    my $rule = Koha::CirculationRules->get_effective_rules({

        branchcode => $branchcode,

        categorycode => $patron ? $patron->categorycode : undef,

        itemtype => $self->effective_itemtype,

        rules => [

            'recalls_allowed',

            'recalls_per_record',

            'on_shelf_recalls',

        ],

    });

    # check recalls allowed has been set and is not zero

    return 0 if ( !defined($rule->{recalls_allowed}) || $rule->{recalls_allowed} == 0 );

    if ( $patron ) {

        # check borrower has not reached open recalls allowed limit

        return 0 if ( $patron->recalls->count >= $rule->{recalls_allowed} );

        # check borrower has not reach open recalls allowed per record limit

        return 0 if ( $patron->recalls({ biblionumber => $self->biblionumber })->count >= $rule->{recalls_per_record} );

        # check if this patron has already recalled this item

        return 0 if ( Koha::Recalls->search({ itemnumber => $self->itemnumber, borrowernumber => $patron->borrowernumber, old => undef })->count > 0 );

        # check if this patron has already checked out this item

        return 0 if ( Koha::Checkouts->search({ itemnumber => $self->itemnumber, borrowernumber => $patron->borrowernumber })->count > 0 );

        # check if this patron has already reserved this item

        return 0 if ( Koha::Holds->search({ itemnumber => $self->itemnumber, borrowernumber => $patron->borrowernumber })->count > 0 );

    }

    # check item availability

    # items are unavailable for recall if they are lost, withdrawn or notforloan

    my @items = Koha::Items->search({ biblionumber => $self->biblionumber, itemlost => 0, withdrawn => 0, notforloan => 0 });

    # if there are no available items at all, no recall can be placed

    return 0 if ( scalar @items == 0 );

    my $checked_out_count = 0;

    foreach (@items) {

        if ( Koha::Checkouts->search({ itemnumber => $_->itemnumber })->count > 0 ){ $checked_out_count++; }

    }

    # can't recall if on shelf recalls only allowed when all unavailable, but items are still available for checkout

    return 0 if ( $rule->{on_shelf_recalls} eq 'all' && $checked_out_count < scalar @items );

    # can't recall if no items have been checked out

    return 0 if ( $checked_out_count == 0 );

    # can recall

    return 1;

}

=head3 can_be_waiting_recall

    if ( $item->can_be_waiting_recall ) { # allocate item as waiting for recall

Checks item type and branch of circ rules to return whether this item can be used to fill a recall.

At this point the item has already been recalled. We are now at the checkin and set waiting stage.

=cut

sub can_be_waiting_recall {

    my ( $self ) = @_;

    return 0 if !( C4::Context->preference('UseRecalls') );

    # check if this item is not for loan, withdrawn or lost

    return 0 if ( $self->notforloan != 0 );

    return 0 if ( $self->itemlost != 0 );

    return 0 if ( $self->withdrawn != 0 );

    my $branchcode = $self->holdingbranch;

    if ( C4::Context->preference('CircControl') eq 'PickupLibrary' and C4::Context->userenv and C4::Context->userenv->{'branch'} ) {

        $branchcode = C4::Context->userenv->{'branch'};

    } else {

        $branchcode = ( C4::Context->preference('HomeOrHoldingBranch') eq 'homebranch' ) ? $self->homebranch : $self->holdingbranch;

    }

    # Check the circulation rule for each relevant itemtype for this item

    my $rule = Koha::CirculationRules->get_effective_rules({

        branchcode => $branchcode,

        categorycode => undef,

        itemtype => $self->effective_itemtype,

        rules => [

            'recalls_allowed',

        ],

    });

    # check recalls allowed has been set and is not zero

    return 0 if ( !defined($rule->{recalls_allowed}) || $rule->{recalls_allowed} == 0 );

    # can recall

    return 1;

}

=head3 check_recalls

    my $recall = $item->check_recalls;

Get the most relevant recall for this item.

=cut

sub check_recalls {

    my ( $self ) = @_;

    my @recalls = Koha::Recalls->search({ biblionumber => $self->biblionumber, itemnumber => [ $self->itemnumber, undef ], status => [ 'R','O','W','T' ] }, { order_by => { -asc => 'recalldate' } });

    my $recall;

    # iterate through relevant recalls to find the best one.

    # if we come across a waiting recall, use this one.

    # if we have iterated through all recalls and not found a waiting recall, use the first recall in the array, which should be the oldest recall.

    foreach my $r ( @recalls ) {

        if ( $r->waiting ) {

            $recall = $r;

            last;

        }

    }

    unless ( defined $recall ) {

        $recall = $recalls[0];

    }

    return $recall;

}

=head3 recalls

    my $recalls = $patron->recalls;

    my $recalls = $patron->recalls({ biblionumber => $biblionumber });

Return the patron's active recalls - total, or on a specific biblio

=cut

sub recalls {

    my ( $self, $params ) = @_;

    my $biblionumber = $params->{biblionumber};

    my $recalls_rs = Koha::Recalls->search({ borrowernumber => $self->borrowernumber, old => undef });

    if ( $biblionumber ) {

        $recalls_rs = Koha::Recalls->search({ borrowernumber => $self->borrowernumber, old => undef, biblionumber => $biblionumber });

    }

    return $recalls_rs;

}

use Koha::Recalls;

sub RecallsCount {

    my ( $self, $biblionumber ) = @_;

    my $recalls = Koha::Recalls->search({ biblionumber => $biblionumber, old => undef });

    return $recalls->count;

}

    # Recalls

    t::lib::Mocks::mock_preference('UseRecalls', 1);

    Koha::CirculationRules->set_rules({

        categorycode => undef,

        branchcode => undef,

        itemtype => undef,

        rules => {

            recalls_allowed => 10,

            renewalsallowed => 5,

        },

    });

    my $recall_borrower = $builder->build_object({ class => 'Koha::Patrons' });

    my $recall_biblio = $builder->build_object({ class => 'Koha::Biblios' });

    my $recall_item1 = $builder->build_object({ class => 'Koha::Items' }, { value => { biblionumber => $recall_biblio->biblionumber } });

    my $recall_item2 = $builder->build_object({ class => 'Koha::Items' }, { value => { biblionumber => $recall_biblio->biblionumber } });

    AddIssue( $renewing_borrower, $recall_item1->barcode );

    # item-level and this item: renewal not allowed

    my $recall = Koha::Recall->new({

        biblionumber => $recall_item1->biblionumber,

        itemnumber => $recall_item1->itemnumber,

        borrowernumber => $recall_borrower->borrowernumber,

        branchcode => $recall_borrower->branchcode,

        item_level_recall => 1,

        status => 'R',

    })->store;

    ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );

    is( $error, 'recalled', 'Cannot renew item that has been recalled' );

    $recall->set_cancelled;

    # biblio-level requested recall: renewal not allowed

    $recall = Koha::Recall->new({

        biblionumber => $recall_item1->biblionumber,

        itemnumber => undef,

        borrowernumber => $recall_borrower->borrowernumber,

        branchcode => $recall_borrower->branchcode,

        item_level_recall => 0,

        status => 'R',

    })->store;

    ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );

    is( $error, 'recalled', 'Cannot renew item if biblio is recalled and has no item allocated' );

    $recall->set_cancelled;

    # item-level and not this item: renewal allowed

    $recall = Koha::Recall->new({

        biblionumber => $recall_item2->biblionumber,

        itemnumber => $recall_item2->itemnumber,

        borrowernumber => $recall_borrower->borrowernumber,

        branchcode => $recall_borrower->branchcode,

        item_level_recall => 1,

        status => 'R',

    })->store;

    ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );

    is( $renewokay, 1, 'Can renew item if item-level recall on biblio is not on this item' );

    $recall->set_cancelled;

    # biblio-level waiting recall: renewal allowed

    $recall = Koha::Recall->new({

        biblionumber => $recall_item1->biblionumber,

        itemnumber => undef,

        borrowernumber => $recall_borrower->borrowernumber,

        branchcode => $recall_borrower->branchcode,

        item_level_recall => 0,

        status => 'R',

    })->store;

    $recall->set_waiting({ item => $recall_item1 });

    ( $renewokay, $error ) = CanBookBeRenewed( $renewing_borrowernumber, $recall_item1->itemnumber );

    is( $renewokay, 1, 'Can renew item if biblio-level recall has already been allocated an item' );

    $recall->set_cancelled;

subtest 'AddIssue | recalls' => sub {

    plan tests => 3;

    t::lib::Mocks::mock_preference("UseRecalls", 1);

    t::lib::Mocks::mock_preference("item-level_itypes", 1);

    my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });

    my $patron2 = $builder->build_object({ class => 'Koha::Patrons' });

    my $item = $builder->build_sample_item;

    Koha::CirculationRules->set_rules({

        branchcode => undef,

        itemtype => undef,

        categorycode => undef,

        rules => {

            recalls_allowed => 10,

        },

    });

    # checking out item that they have recalled

    my $recall1 = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        biblionumber => $item->biblionumber,

        itemnumber => $item->itemnumber,

        item_level_recall => 1,

        branchcode => $patron1->branchcode,

        status => 'R',

    })->store;

    AddIssue( $patron1->unblessed, $item->barcode, undef, undef, undef, undef, { recall_id => $recall1->recall_id } );

    $recall1 = Koha::Recalls->find( $recall1->recall_id );

    is( $recall1->finished, 1, 'Recall was fulfilled when patron checked out item' );

    AddReturn( $item->barcode, $item->homebranch );

    # this item is has a recall request. cancel recall

    my $recall2 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        biblionumber => $item->biblionumber,

        itemnumber => $item->itemnumber,

        item_level_recall => 1,

        branchcode => $patron2->branchcode,

        status => 'R',

    })->store;

    AddIssue( $patron1->unblessed, $item->barcode, undef, undef, undef, undef, { recall_id => $recall2->recall_id, cancel_recall => 'cancel' } );

    $recall2 = Koha::Recalls->find( $recall2->recall_id );

    is( $recall2->cancelled, 1, 'Recall was cancelled when patron checked out item' );

    AddReturn( $item->barcode, $item->homebranch );

    # this item is waiting to fulfill a recall. revert recall

    my $recall3 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        biblionumber => $item->biblionumber,

        itemnumber => $item->itemnumber,

        item_level_recall => 1,

        branchcode => $patron2->branchcode,

        status => 'R',

    })->store;

    $recall3->set_waiting;

    AddIssue( $patron1->unblessed, $item->barcode, undef, undef, undef, undef, { recall_id => $recall3->recall_id, cancel_recall => 'revert' } );

    $recall3 = Koha::Recalls->find( $recall3->recall_id );

    is( $recall3->requested, 1, 'Recall was reverted from waiting when patron checked out item' );

    AddReturn( $item->barcode, $item->homebranch );

};

subtest 'CanBookBeIssued | recalls' => sub {

    plan tests => 3;

    t::lib::Mocks::mock_preference("UseRecalls", 1);

    t::lib::Mocks::mock_preference("item-level_itypes", 1);

    my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });

    my $patron2 = $builder->build_object({ class => 'Koha::Patrons' });

    my $item = $builder->build_sample_item;

    Koha::CirculationRules->set_rules({

        branchcode => undef,

        itemtype => undef,

        categorycode => undef,

        rules => {

            recalls_allowed => 10,

        },

    });

    # item-level recall

    my $recall = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        biblionumber => $item->biblionumber,

        itemnumber => $item->itemnumber,

        item_level_recall => 1,

        branchcode => $patron1->branchcode,

        status => 'R',

    })->store;

    my ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron2, $item->barcode, undef, undef, undef, undef );

    is( $needsconfirmation->{RECALLED}->recall_id, $recall->recall_id, "Another patron has placed an item-level recall on this item" );

    $recall->set_cancelled;

    # biblio-level recall

    $recall = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        biblionumber => $item->biblionumber,

        itemnumber => undef,

        item_level_recall => 0,

        branchcode => $patron1->branchcode,

        status => 'R',

    })->store;

    ( $issuingimpossible, $needsconfirmation ) = CanBookBeIssued( $patron2, $item->barcode, undef, undef, undef, undef );

    is( $needsconfirmation->{RECALLED}->recall_id, $recall->recall_id, "Another patron has placed a biblio-level recall and this item is eligible to fill it" );

    $recall->set_cancelled;

    # biblio-level recall

    $recall = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        biblionumber => $item->biblionumber,

        itemnumber => undef,

        item_level_recall => 0,

        branchcode => $patron1->branchcode,

        status => 'R',

    })->store;

    $recall->set_waiting({ item => $item, expirationdate => dt_from_string() });

    my ( undef, undef, undef, $messages ) = CanBookBeIssued( $patron1, $item->barcode, undef, undef, undef, undef );

    is( $messages->{RECALLED}, $recall->recall_id, "This book can be issued by this patron and they have placed a recall" );

    $recall->set_cancelled;

};

subtest 'AddReturn | recalls' => sub {

    plan tests => 3;

    t::lib::Mocks::mock_preference("UseRecalls", 1);

    t::lib::Mocks::mock_preference("item-level_itypes", 1);

    my $patron1 = $builder->build_object({ class => 'Koha::Patrons' });

    my $patron2 = $builder->build_object({ class => 'Koha::Patrons' });

    my $item1 = $builder->build_sample_item;

    Koha::CirculationRules->set_rules({

        branchcode => undef,

        itemtype => undef,

        categorycode => undef,

        rules => {

            recalls_allowed => 10,

        },

    });

    # this item can fill a recall with pickup at this branch

    AddIssue( $patron1->unblessed, $item1->barcode );

    my $recall1 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        biblionumber => $item1->biblionumber,

        itemnumber => $item1->itemnumber,

        item_level_recall => 1,

        branchcode => $item1->homebranch,

        status => 'R',

    })->store;

    my ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $item1->barcode, $item1->homebranch );

    is( $messages->{RecallFound}->recall_id, $recall1->recall_id, "Recall found" );

    $recall1->set_cancelled;

    # this item can fill a recall but needs transfer

    AddIssue( $patron1->unblessed, $item1->barcode );

    $recall1 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        biblionumber => $item1->biblionumber,

        itemnumber => $item1->itemnumber,

        item_level_recall => 1,

        branchcode => $patron2->branchcode,

        status => 'R',

    })->store;

    ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $item1->barcode, $item1->homebranch );

    is( $messages->{RecallNeedsTransfer}, $item1->homebranch, "Recall requiring transfer found" );

    $recall1->set_cancelled;

    # this item is already in transit, do not ask to transfer

    AddIssue( $patron1->unblessed, $item1->barcode );

    $recall1 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        biblionumber => $item1->biblionumber,

        itemnumber => $item1->itemnumber,

        item_level_recall => 1,

        branchcode => $patron2->branchcode,

        status => 'R',

    })->store;

    $recall1->start_transfer;

    ( $doreturn, $messages, $iteminfo, $borrowerinfo ) = AddReturn( $item1->barcode, $patron2->branchcode );

    is( $messages->{TransferredRecall}->recall_id, $recall1->recall_id, "In transit recall found" );

    $recall1->set_cancelled;

};

my $schema = Koha::Database->new->schema;

$schema->storage->txn_begin;

    # recalls

    t::lib::Mocks::mock_preference('UseRecalls', 1);

    my $recall = Koha::Recall->new({

        biblionumber => $item->biblionumber,

        itemnumber => $item->itemnumber,

        item_level_recall => 1,

        borrowernumber => $patron->borrowernumber,

        branchcode => $library->branchcode,

        status => 'R',

    })->store;

    ( $recall, $dotransfer, $messages ) = $recall->start_transfer;

    is( $dotransfer, 0, 'Do not transfer recalled item, it has already arrived' );

    is( $messages->{RecallPlacedAtHoldingBranch}, 1, "We found the recall");

    my $item2 = $builder->build_object({ class => 'Koha::Items' }); # this item will have a different holding branch to the pickup branch

    $recall = Koha::Recall->new({

        biblionumber => $item2->biblionumber,

        itemnumber => $item2->itemnumber,

        item_level_recall => 1,

        borrowernumber => $patron->borrowernumber,

        branchcode => $library->branchcode,

        status => 'R',

    })->store;

    ( $recall, $dotransfer, $messages ) = $recall->start_transfer;

    is( $dotransfer, 1, 'Transfer of recalled item succeeded' );

    is( $messages->{RecallFound}->recall_id, $recall->recall_id, "We found the recall");

$schema->storage->txn_rollback;

};

subtest 'CanItemBeReserved / recall' => sub {

    plan tests => 1;

    $schema->storage->txn_begin;

    my $itemtype1 = $builder->build_object( { class => 'Koha::ItemTypes' } );

    my $library1  = $builder->build_object( { class => 'Koha::Libraries', value => {pickup_location => 1} } );

    my $patron1   = $builder->build_object( { class => 'Koha::Patrons', value => {branchcode => $library1->branchcode} } );

    my $biblio1 = $builder->build_sample_biblio({ itemtype => $itemtype1->itemtype });

    my $item1   = $builder->build_sample_item(

        {

            biblionumber => $biblio1->biblionumber,

            library      => $library1->branchcode

        }

    );

    Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        biblionumber => $biblio1->biblionumber,

        branchcode => $library1->branchcode,

        itemnumber => $item1->itemnumber,

        recalldate => '2020-05-04 10:10:10',

        item_level_recall => 1,

    })->store;

    is( CanItemBeReserved( $patron1->borrowernumber, $item1->itemnumber, $library1->branchcode )->{status}, 'recall', "Can't reserve an item that they have already recalled" );

    $schema->storage->txn_rollback;

subtest 'Recalls tests' => sub {

    plan tests => 12;

    $schema->storage->txn_begin;

    my $item1 = $builder->build_sample_item;

    my $biblio = $item1->biblio;

    my $branchcode = $item1->holdingbranch;

    my $patron1 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });

    my $patron2 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });

    my $patron3 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });

    my $item2 = $builder->build_object({ class => 'Koha::Items', value => { holdingbranch => $branchcode, homebranch => $branchcode, biblionumber => $biblio->biblionumber, itype => $item1->effective_itemtype } });

    t::lib::Mocks::mock_userenv({ patron => $patron1 });

    my $recall1 = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => $item1->itemnumber,

        expirationdate => undef,

        item_level_recall => 1

    })->store;

    my $recall2 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => undef,

        expirationdate => undef,

        item_level_recall => 0

    })->store;

    my $recall3 = Koha::Recall->new({

        borrowernumber => $patron3->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => $item1->itemnumber,

        expirationdate => undef,

        item_level_recall => 1

    })->store;

    my $recalls_count = scalar $biblio->recalls;

    is( $recalls_count, 3, 'Correctly get number of active recalls for biblio' );

    $recall1->set_cancelled;

    $recall2->set_expired({ interface => 'COMMANDLINE' });

    $recalls_count = scalar $biblio->recalls;

    is( $recalls_count, 1, 'Correctly get number of active recalls for biblio' );

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

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall with UseRecalls disabled" );

    t::lib::Mocks::mock_preference("UseRecalls", 1);

    $item1->update({ notforloan => 1 });

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall with no available items" );

    $item1->update({ notforloan => 0 });

    Koha::CirculationRules->set_rules({

        branchcode => $branchcode,

        categorycode => $patron1->categorycode,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 0,

            recalls_per_record => 1,

            on_shelf_recalls => 'all',

        },

    });

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if recalls_allowed = 0" );

    Koha::CirculationRules->set_rules({

        branchcode => $branchcode,

        categorycode => $patron1->categorycode,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 1,

            recalls_per_record => 1,

            on_shelf_recalls => 'all',

        },

    });

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_allowed" );

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_per_record" );

    $recall1->set_cancelled;

    C4::Circulation::AddIssue( $patron1->unblessed, $item2->barcode );

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has already checked out an item attached to this biblio" );

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if on_shelf_recalls = all and items are still available" );

    Koha::CirculationRules->set_rules({

        branchcode => $branchcode,

        categorycode => $patron1->categorycode,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 1,

            recalls_per_record => 1,

            on_shelf_recalls => 'any',

        },

    });

    C4::Circulation::AddReturn( $item2->barcode, $branchcode );

    is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if no items are checked out" );

    $recall2->set_cancelled;

    C4::Circulation::AddIssue( $patron2->unblessed, $item2->barcode );

    C4::Circulation::AddIssue( $patron2->unblessed, $item1->barcode );

    is( $biblio->can_be_recalled({ patron => $patron1 }), 2, "Can recall two items" );

    $item1->update({ withdrawn => 1 });

    is( $biblio->can_be_recalled({ patron => $patron1 }), 1, "Can recall one item" );

    $schema->storage->txn_rollback;

};

subtest 'Recalls tests' => sub {

    plan tests => 20;

    $schema->storage->txn_begin;

    my $item1 = $builder->build_sample_item;

    my $biblio = $item1->biblio;

    my $branchcode = $item1->holdingbranch;

    my $patron1 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });

    my $patron2 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });

    my $patron3 = $builder->build_object({ class => 'Koha::Patrons', value => { branchcode => $branchcode } });

    my $item2 = $builder->build_object({ class => 'Koha::Items', value => { holdingbranch => $branchcode, homebranch => $branchcode, biblionumber => $biblio->biblionumber, itype => $item1->effective_itemtype } });

    t::lib::Mocks::mock_userenv({ patron => $patron1 });

    my $recall1 = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => $item1->itemnumber,

        expirationdate => undef,

        item_level_recall => 1

    })->store;

    my $recall2 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => $item1->itemnumber,

        expirationdate => undef,

        item_level_recall =>1

    })->store;

    is( $item1->recall->borrowernumber, $patron1->borrowernumber, 'Correctly returns most relevant recall' );

    $recall2->set_cancelled;

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

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall with UseRecalls disabled" );

    t::lib::Mocks::mock_preference("UseRecalls", 1);

    $item1->update({ notforloan => 1 });

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall that is not for loan" );

    $item1->update({ notforloan => 0, itemlost => 1 });

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall that is marked lost" );

    $item1->update({ itemlost => 0, withdrawn => 1 });

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall that is withdrawn" );

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall item if not checked out" );

    $item1->update({ withdrawn => 0 });

    C4::Circulation::AddIssue( $patron2->unblessed, $item1->barcode );

    Koha::CirculationRules->set_rules({

        branchcode => $branchcode,

        categorycode => $patron1->categorycode,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 0,

            recalls_per_record => 1,

            on_shelf_recalls => 'all',

        },

    });

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if recalls_allowed = 0" );

    Koha::CirculationRules->set_rules({

        branchcode => $branchcode,

        categorycode => $patron1->categorycode,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 1,

            recalls_per_record => 1,

            on_shelf_recalls => 'all',

        },

    });

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_allowed" );

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_per_record" );

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has already recalled this item" );

    my $reserve_id = C4::Reserves::AddReserve({ branchcode => $branchcode, borrowernumber => $patron1->borrowernumber, biblionumber => $item1->biblionumber, itemnumber => $item1->itemnumber });

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall item if patron has already reserved it" );

    C4::Reserves::ModReserve({ rank => 'del', reserve_id => $reserve_id, branchcode => $branchcode, itemnumber => $item1->itemnumber, borrowernumber => $patron1->borrowernumber, biblionumber => $item1->biblionumber });

    $recall1->set_cancelled;

    is( $item1->can_be_recalled({ patron => $patron2 }), 0, "Can't recall if patron has already checked out an item attached to this biblio" );

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if on_shelf_recalls = all and items are still available" );

    Koha::CirculationRules->set_rules({

        branchcode => $branchcode,

        categorycode => $patron1->categorycode,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 1,

            recalls_per_record => 1,

            on_shelf_recalls => 'any',

        },

    });

    C4::Circulation::AddReturn( $item1->barcode, $branchcode );

    is( $item1->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if no items are checked out" );

    C4::Circulation::AddIssue( $patron2->unblessed, $item1->barcode );

    is( $item1->can_be_recalled({ patron => $patron1 }), 1, "Can recall item" );

    $recall1 = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => undef,

        expirationdate => undef,

        item_level_recall => 0

    })->store;

    # Patron2 has Item1 checked out. Patron1 has placed a biblio-level recall on Biblio1, so check if Item1 can fulfill Patron1's recall.

    Koha::CirculationRules->set_rules({

        branchcode => undef,

        categorycode => undef,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 0,

            recalls_per_record => 1,

            on_shelf_recalls => 'any',

        },

    });

    is( $item1->can_be_waiting_recall, 0, "Recalls not allowed for this itemtype" );

    Koha::CirculationRules->set_rules({

        branchcode => undef,

        categorycode => undef,

        itemtype => $item1->effective_itemtype,

        rules => {

            recalls_allowed => 1,

            recalls_per_record => 1,

            on_shelf_recalls => 'any',

        },

    });

    is( $item1->can_be_waiting_recall, 1, "Recalls are allowed for this itemtype" );

    # check_recalls tests

    $recall1 = Koha::Recall->new({

        borrowernumber => $patron2->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => $item1->itemnumber,

        expirationdate => undef,

        item_level_recall => 1

    })->store;

    $recall2 = Koha::Recall->new({

        borrowernumber => $patron1->borrowernumber,

        recalldate => Koha::DateUtils::dt_from_string,

        biblionumber => $biblio->biblionumber,

        branchcode => $branchcode,

        status => 'R',

        itemnumber => undef,

        expirationdate => undef,

        item_level_recall => 0

    })->store;

    $recall2->set_waiting({ item => $item1 });

    # return a waiting recall

    my $check_recall = $item1->check_recalls;

    is( $check_recall->borrowernumber, $patron1->borrowernumber, "Waiting recall is highest priority and returned" );

    $recall2->revert_waiting;

    # return recall based on recalldate

    $check_recall = $item1->check_recalls;

    is( $check_recall->borrowernumber, $patron1->borrowernumber, "No waiting recall, so oldest recall is returned" );

    $recall1->set_cancelled;

    # return a biblio-level recall

    $check_recall = $item1->check_recalls;

    is( $check_recall->borrowernumber, $patron1->borrowernumber, "Only remaining recall is returned" );

    $recall2->set_cancelled;

};

subtest 'recalls() tests' => sub {

    plan tests => 2;

    $schema->storage->txn_begin;

    my $patron = $builder->build_object({ class => 'Koha::Patrons' });

    my $biblio1 = $builder->build_object({ class => 'Koha::Biblios' });

    my $item1 = $builder->build_object({ class => 'Koha::Items' }, { value => { biblionumber => $biblio1->biblionumber } });

    my $biblio2 = $builder->build_object({ class => 'Koha::Biblios' });

    my $item2 = $builder->build_object({ class => 'Koha::Items' }, { value => { biblionumber => $biblio2->biblionumber } });

    Koha::Recall->new({

        biblionumber => $biblio1->biblionumber,

        borrowernumber => $patron->borrowernumber,

        itemnumber => $item1->itemnumber,

        branchcode => $patron->branchcode,

        recalldate => dt_from_string,

        status => 'R',

        item_level_recall => 1,

    })->store;

    Koha::Recall->new({

        biblionumber => $biblio2->biblionumber,

        borrowernumber => $patron->borrowernumber,

        itemnumber => $item2->itemnumber,

        branchcode => $patron->branchcode,

        recalldate => dt_from_string,

        status => 'R',

        item_level_recall => 1,

    })->store;

    Koha::Recall->new({

        biblionumber => $biblio1->biblionumber,

        borrowernumber => $patron->borrowernumber,

        itemnumber => undef,

        branchcode => $patron->branchcode,

        recalldate => dt_from_string,

        status => 'R',

        item_level_recall => 0,

    })->store;

    my $recall = Koha::Recall->new({

        biblionumber => $biblio1->biblionumber,

        borrowernumber => $patron->borrowernumber,

        itemnumber => undef,

        branchcode => $patron->branchcode,

        recalldate => dt_from_string,

        status => 'R',

        item_level_recall => 0,

    })->store;

    $recall->set_cancelled;

    is( $patron->recalls->count, 3, "Correctly gets this patron's active recalls" );

    is( $patron->recalls({ biblionumber => $biblio1->biblionumber })->count, 2, "Correctly gets this patron's active recalls on a specific biblio" );

    $schema->storage->txn_rollback;

};

    my $recall = $builder->build_object({ class => 'Koha::Recalls', value => {

        biblionumber    => $item->biblionumber,

        itemnumber      => $item->itemnumber,

        branchcode      => $item->holdingbranch,

        status          => 'R',

    }});

    $recall->set_waiting;

    $xml = C4::XSLT::buildKohaItemsNamespace( $item->biblionumber,[]);

    like($xml,qr{<status>Waiting</status>},"Waiting status takes precedence over In transit (recalls)");