Attachment #144722 for bug #32496

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






sub TooMany {
    my ($patron, $item, $params) = @_;
    my $item_object = shift;
    my $params = shift;
    my $onsite_checkout = $params->{onsite_checkout} || 0;
    my $switch_onsite_checkout = $params->{switch_onsite_checkout} || 0;
    my $cat_borrower    = $patron->categorycode;
    my $dbh             = C4::Context->dbh;
    # Get which branchcode we need
    my $branch = _GetCircControlBranch($item, $patron);
    my $type = $item->effective_itemtype;

    my ($type_object, $parent_type, $parent_maxissueqty_rule);
    $type_object = Koha::ItemTypes->find( $type );

        }
    );


    my $patron = Koha::Patrons->find($borrower->{borrowernumber});
    # if a rule is found and has a loan limit set, count
    # how many loans the patron already has that meet that
    # rule

    my $dbh             = C4::Context->dbh;
    my $patron_unblessed = $patron->unblessed;

    my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_object, $patron) );

    my $now = dt_from_string();
    $duedate ||= CalcDateDue( $now, $effective_itemtype, $circ_library->branchcode, $patron );
    if (DateTime->compare($duedate,$now) == -1 ) { # duedate cannot be before now
         $needsconfirmation{INVALID_DATE} = $duedate;
    }

      and $issue
      and $issue->onsite_checkout
      and $issue->borrowernumber == $patron->borrowernumber ? 1 : 0 );
    my $toomany = TooMany( $patron, $item_object, { onsite_checkout => $onsite_checkout, switch_onsite_checkout => $switch_onsite_checkout, } );
    # if TooMany max_allowed returns 0 the user doesn't have permission to check out this book
    if ( $toomany && not exists $needsconfirmation{RENEW_ISSUE} ) {
        if ( $toomany->{max_allowed} == 0 ) {


sub checkHighHolds {
    my ( $item, $patron ) = @_;
    my $branchcode = _GetCircControlBranch( $item, $patron );

    my $return_data = {
        exceeded    => 0,

        );
        my $calendar = Koha::Calendar->new( branchcode => $branchcode, days_mode => $daysmode );

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

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


=head2 AddIssue

  &AddIssue($patron, $barcode, [$datedue], [$cancelreserve], [$issuedate])

Issue a book. Does no check, they are done in CanBookBeIssued. If we reach this sub, it means the user confirmed if needed.

=over 4

=item C<$patron> is a patron object.

=item C<$barcode> is the barcode of the item being issued.


=cut

sub AddIssue {
    my ( $patron, $barcode, $datedue, $cancelreserve, $issuedate, $sipmode, $params ) = @_;

    my $onsite_checkout = $params && $params->{onsite_checkout} ? 1 : 0;
    my $switch_onsite_checkout = $params && $params->{switch_onsite_checkout};

    }

    # Stop here if the patron or barcode doesn't exist
    if ( $patron && $barcode && $barcodecheck ) {
        # find which item we issue
        my $item_object = Koha::Items->find({ barcode => $barcode })
          or return;    # if we don't get an Item, abort.
        my $item_unblessed = $item_object->unblessed;

        my $branchcode = _GetCircControlBranch( $item_object, $patron );

        # get actual issuing if there is one
        my $actualissue = $item_object->checkout;

        # check if we just renew the issue.
        if ( $actualissue and $actualissue->borrowernumber eq $patron->borrowernumber
                and not $switch_onsite_checkout ) {
            $datedue = AddRenewal(
                $patron->borrowernumber,
                $item_object->itemnumber,
                $branchcode,
                $datedue,


            unless ($datedue) {
                my $itype = $item_object->effective_itemtype;
                $datedue = CalcDateDue( $issuedate, $itype, $branchcode, $patron );

            }


                # Check if there is an ILL connected with the biblio of the item we are issuing
                my $ill_request = Koha::Illrequests->search({
                    biblio_id => $item_object->biblionumber,
                    borrowernumber => $patron->borrowernumber,
                    completed => undef,
                    due_date => { '!=', undef },
                })->next;


            $datedue->truncate( to => 'minute' );

            my $patron = Koha::Patrons->find( $borrower );
            my $library = Koha::Libraries->find( $branchcode );
            my $fees = Koha::Charges::Fees->new(
                {

                        action         => $cancel_recall,
                        recall_id      => $recall_id,
                        item           => $item_object,
                        borrowernumber => $patron->borrowernumber,
                    }
                );
            }

            C4::Reserves::MoveReserve( $item_object->itemnumber, $patron->borrowernumber, $cancelreserve );

            # Starting process for transfer job (checking transfert and validate it if we have one)
            if ( my $transfer = $item_object->get_transfer ) {

            unless ($auto_renew) {
                my $rule = Koha::CirculationRules->get_effective_rule_value(
                    {
                        categorycode => $patron->categorycode,
                        itemtype     => $item_object->effective_itemtype,
                        branchcode   => $branchcode,
                        rule_name    => 'auto_renew'

            }

            my $issue_attributes = {
                borrowernumber  => $patron->borrowernumber,
                issuedate       => $issuedate,
                date_due        => $datedue,
                branchcode      => C4::Context->userenv->{'branch'},

                )->store;
            }
            $issue->discard_changes;
            C4::Auth::track_login_daily( $patron->userid );
            if ( $item_object->location && $item_object->location eq 'CART'
                && ( !$item_object->permanent_location || $item_object->permanent_location ne 'CART' ) ) {
            ## Item was moved to cart via UpdateItemLocationOnCheckin, anything issued should be taken off the cart.

            if ($was_lost) {
                if ( $item_object->{_charge} ) {
                    $actualissue //= Koha::Old::Checkouts->search(
                        { itemnumber => $item_object->itemnumber },
                        {
                            order_by => { '-desc' => 'returndate' },
                            rows     => 1
                        }
                    )->single;
                    unless ( $patron->branchcode ) {
                        $patron = $actualissue->patron;
                        $borrower = $patron->unblessed;
                    }
                    _CalculateAndUpdateFine(
                        {
                            issue       => $actualissue,
                            item        => $item_unblessed,
                            borrower    => $patron->unblessed,
                            return_date => $issuedate
                        }
                    );
                    _FixOverduesOnReturn( $patron->borrowernumber,
                        $item_object->itemnumber, undef, 'RENEWED' );
                }
            }

            # If it costs to borrow this book, charge it to the patron's account.
            my ( $charge, $itemtype ) = GetIssuingCharges( $item_object->itemnumber, $patron->borrowernumber );
            if ( $charge && $charge > 0 ) {
                AddIssuingCharge( $issue, $charge, 'RENT' );
            }

                    itemnumber     => $item_object->itemnumber,
                    itemtype       => $item_object->effective_itemtype,
                    location       => $item_object->location,
                    borrowernumber => $patron->borrowernumber,
                    ccode          => $item_object->ccode,
                    categorycode   => $patron->categorycode
                }
            );


            my $circulation_alert = 'C4::ItemCirculationAlertPreference';
            my %conditions        = (
                branchcode   => $branchcode,
                categorycode => $patron->categorycode,
                item_type    => $item_object->effective_itemtype,
                notification => 'CHECKOUT',
            );

                    {
                        type     => 'CHECKOUT',
                        item     => $item_object->unblessed,
                        borrower => $patron->unblessed,
                        branch   => $branchcode,
                    }
                );
            }
            logaction(
                "CIRCULATION", "ISSUE",
                $patron->borrowernumber,
                $item_object->itemnumber,
            ) if C4::Context->preference("IssueLog");



        if ( $issue and $issue->is_overdue($return_date) ) {
        # fix fine days
            my ( $debardate, $reminder ) = _debar_user_on_return( $patron, $item, dt_from_string($issue->date_due), $return_date );
            if ($reminder){
                $messages->{'PrevDebarred'} = $debardate;
            } else {


=head2 _debar_user_on_return

    _debar_user_on_return($patron, $item, $datedue, $returndate);

C<$patron> patron object

C<$item> patron object

C<$datedue> date due DateTime object


=cut

sub _calculate_new_debar_dt {
    my ( $patron, $item, $dt_due, $return_date ) = @_;

    my $branchcode = _GetCircControlBranch( $item, $patron );
    my $circcontrol = C4::Context->preference('CircControl');
    my $issuing_rule = Koha::CirculationRules->get_effective_rules(
        {   categorycode => $patron->categorycode,
            itemtype     => $item->effective_itemtype,
            branchcode   => $branchcode,
            rules => [
                'finedays',

        }

        my ( $has_been_extended );
        if ( C4::Context->preference('CumulativeRestrictionPeriods') and $patron->is_debarred ) {
            my $debarment = @{ GetDebarments( { borrowernumber => $patron->borrowernumber, type => 'SUSPENSION' } ) }[0];
            if ( $debarment ) {
                $return_date = dt_from_string( $debarment->{expiration}, 'sql' );
                $has_been_extended = 1;

}

sub _debar_user_on_return {
    my ( $patron, $item, $dt_due, $return_date ) = @_;

    $return_date //= dt_from_string();

    my $new_debar_dt = _calculate_new_debar_dt($patron, $item, $dt_due, $return_date);

    return unless $new_debar_dt;

    Koha::Patron::Debarments::AddUniqueDebarment({
        borrowernumber => $patron->borrowernumber,
        expiration     => $new_debar_dt->ymd(),
        type           => 'SUSPENSION',
    });
    # if borrower was already debarred but does not get an extra debarment
    my $patron = Koha::Patrons->find( $borrower->{borrowernumber} );
    my ($new_debarment_str, $is_a_reminder);
    if ( $patron->is_debarred ) {
        $is_a_reminder = 1;
        $new_debarment_str = $patron->debarred;
    } else {
        $new_debarment_str = $new_debar_dt->ymd();
    }


=head2 _GetCircControlBranch

   my $circ_control_branch = _GetCircControlBranch($item, $patron);

Internal function :

Return the library code to be used to determine which circulation
policy applies to a transaction.  Looks up the CircControl and
HomeOrHoldingBranch system preferences.

C<$item> is an item object.

C<$patron> is a patron object.

=cut

sub _GetCircControlBranch {
    my ($item, $patron) = @_;
    my $circcontrol = C4::Context->preference('CircControl');
    my $branch;

    if ($circcontrol eq 'PickupLibrary' and (C4::Context->userenv and C4::Context->userenv->{'branch'}) ) {
        $branch = C4::Context->userenv->{'branch'};
    } elsif ($circcontrol eq 'PatronLibrary') {
        $branch = $patron->branchcode;
    } else {
        my $branchfield = C4::Context->preference('HomeOrHoldingBranch') || 'homebranch';
        $branch = $item->get_column($branchfield);
        # default to item home branch if holdingbranch is used
        # and is not defined
        if (!defined($branch) && $branchfield eq 'holdingbranch') {
            $branch = $item->homebranch;
        }
    }
    return $branch;


       # override_limit will override anything else except on_reserve
    unless ( $override_limit ){
        my $branchcode = _GetCircControlBranch( $item, $patron );
        my $issuing_rule = Koha::CirculationRules->get_effective_rules(
            {
                categorycode => $patron->categorycode,

    my $patron = Koha::Patrons->find( $borrowernumber ) or return; # FIXME Should do more than just return
    my $patron_unblessed = $patron->unblessed;

    my $circ_library = Koha::Libraries->find( _GetCircControlBranch($item_object, $patron) );

    my $schema = Koha::Database->schema;
    $schema->txn_do(sub{

            $datedue = (C4::Context->preference('RenewalPeriodBase') eq 'date_due') ?
                                            dt_from_string( $issue->date_due, 'sql' ) :
                                            dt_from_string();
            $datedue =  CalcDateDue($datedue, $itemtype, $circ_library->branchcode, $patron, 'is a renewal');
        }

        my $fees = Koha::Charges::Fees->new(

    $renewcount = $data->{'renewals_count'} if $data->{'renewals_count'};
    $unseencount = $data->{'unseen_renewals'} if $data->{'unseen_renewals'};
    # $item and $borrower should be calculated
    my $branchcode = _GetCircControlBranch($item, $patron);

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


    my $dbh = C4::Context->dbh;

    my $branchcode = _GetCircControlBranch( $item, $patron );
    my $issuing_rule = Koha::CirculationRules->get_effective_rules(
        {   categorycode => $patron->categorycode,
            itemtype     => $item->effective_itemtype,

    return unless $item;

    my $dbh = C4::Context->dbh;

    my $branchcode = _GetCircControlBranch( $item->unblessed, $patron->unblessed );

    my $circulation_rules = Koha::CirculationRules->get_effective_rules(
        {
            categorycode => $patron->categorycode,

C<$startdate>   = DateTime object representing start date of loan period (assumed to be today)
C<$itemtype>  = itemtype code of item in question
C<$branch>  = location whose calendar to use
C<$patron> = Patron object
C<$isrenewal> = Boolean: is true if we want to calculate the date due for a renewal. Else is false.

=cut

sub CalcDateDue {
    my ( $startdate, $itemtype, $branch, $patron, $isrenewal ) = @_;

    $isrenewal ||= 0;

    # loanlength now a href
    my $loanlength =
            GetLoanLength( $patron->categorycode, $itemtype, $branch );

    my $length_key = ( $isrenewal and defined $loanlength->{renewalperiod} and $loanlength->{renewalperiod} ne q{} )
            ? qq{renewalperiod}


    my $daysmode = Koha::CirculationRules->get_effective_daysmode(
        {
            categorycode => $patron->categorycode,
            itemtype     => $itemtype,
            branchcode   => $branch,
        }


    # if Hard Due Dates are used, retrieve them and apply as necessary
    my ( $hardduedate, $hardduedatecompare ) =
      GetHardDueDate( $patron->categorycode, $itemtype, $branch );
    if ($hardduedate) {    # hardduedates are currently dates
        $hardduedate->truncate( to => 'minute' );
        $hardduedate->set_hour(23);


    # if ReturnBeforeExpiry ON the datedue can't be after borrower expirydate
    if ( C4::Context->preference('ReturnBeforeExpiry') ) {
        my $expiry_dt = dt_from_string( $patron->dateexpiry, 'iso', 'floating');
        if( $expiry_dt ) { #skip empty expiry date..
            $expiry_dt->set( hour => 23, minute => 59);
            my $d1= $datedue->clone->set_time_zone('floating');

            );
        }
        AddIssue(
            $patron,
            $operation->{'barcode'},
            undef,
            undef,

Lines 141-147 sub do_checkout { Link Here

(-)a/C4/SIP/ILS/Transaction/Checkout.pm (-1 / +1 lines)
141	});	141	});
142	} else {	142	} else {
143	# can issue	143	# can issue
144	my $issue = AddIssue( $patron->unblessed, $barcode, $overridden_duedate, 0 );	144	my $issue = AddIssue( $patron, $barcode, $overridden_duedate, 0 );
145	$self->{due} = $self->duedatefromissue($issue, $itemnumber);	145	$self->{due} = $self->duedatefromissue($issue, $itemnumber);
146	}	146	}
147		147

Lines 46-52 sub do_renew_for { Link Here

(-)a/C4/SIP/ILS/Transaction/Renew.pm (-1 / +1 lines)
46		46
47	}	47	}
48	if ($renewokay){	48	if ($renewokay){
49	my $issue = AddIssue( $borrower, $self->{item}->id, undef, 0 );	49	my $issue = AddIssue( $patron, $self->{item}->id, undef, 0 );
50	$self->{due} = $self->duedatefromissue($issue, $self->{item}->{itemnumber});	50	$self->{due} = $self->duedatefromissue($issue, $self->{item}->{itemnumber});
51	$self->renewal_ok(1);	51	$self->renewal_ok(1);
52	} else {	52	} else {

Lines 250-256 sub mark_as_delivered { Link Here

(-)a/Koha/CurbsidePickup.pm (-1 / +1 lines)
250		250
251	unless ( keys %$issuingimpossible ) {	251	unless ( keys %$issuingimpossible ) {
252	my $issue =	252	my $issue =
253	C4::Circulation::AddIssue( $patron->unblessed, $hold->item->barcode );	253	C4::Circulation::AddIssue( $patron, $hold->item->barcode );
254	if ($issue) {	254	if ($issue) {
255	Koha::CurbsidePickupIssue->new(	255	Koha::CurbsidePickupIssue->new(
256	{	256	{

Lines 1320-1327 sub check_out { Link Here

(-)a/Koha/Illrequest.pm (-2 lines)
1320	}	1320	}
1321		1321
1322	# We can allegedly check out, so make it so	1322	# We can allegedly check out, so make it so
1323	# For some reason, AddIssue requires an unblessed Patron
1324	$issue_args[0] = $patron->unblessed;
1325	my $issue = C4::Circulation::AddIssue(@issue_args);	1323	my $issue = C4::Circulation::AddIssue(@issue_args);
1326		1324
1327	if ($issue) {	1325	if ($issue) {

Lines 1869-1875 sub can_be_recalled { Link Here

(-)a/Koha/Item.pm (-1 / +1 lines)
1869		1869
1870	my $branchcode = C4::Context->userenv->{'branch'};	1870	my $branchcode = C4::Context->userenv->{'branch'};
1871	if ( $patron ) {	1871	if ( $patron ) {
1872	$branchcode = C4::Circulation::_GetCircControlBranch( $self->unblessed, $patron->unblessed );	1872	$branchcode = C4::Circulation::_GetCircControlBranch( $self, $patron );
1873	}	1873	}
1874		1874
1875	# Check the circulation rule for each relevant itemtype for this item	1875	# Check the circulation rule for each relevant itemtype for this item

Lines 258-264 sub calc_expirationdate { Link Here

(-)a/Koha/Recall.pm (-1 / +1 lines)
258		258
259	my $branchcode = $self->patron->branchcode;	259	my $branchcode = $self->patron->branchcode;
260	if ( $item ) {	260	if ( $item ) {
261	$branchcode = C4::Circulation::_GetCircControlBranch( $item->unblessed, $self->patron->unblessed );	261	$branchcode = C4::Circulation::_GetCircControlBranch( $item, $self->patron );
262	}	262	}
263		263
264	my $rule = Koha::CirculationRules->get_effective_rule({	264	my $rule = Koha::CirculationRules->get_effective_rule({

Lines 400-406 if (@$barcodes) { Link Here

(-)a/circ/circulation.pl (-1 / +1 lines)
400	);	400	);
401	$recall_id = ( $recall and $recall->id ) ? $recall->id : undef;	401	$recall_id = ( $recall and $recall->id ) ? $recall->id : undef;
402	}	402	}
403	my $issue = AddIssue( $patron->unblessed, $barcode, $datedue, $cancelreserve, undef, undef, { onsite_checkout => $onsite_checkout, auto_renew => $session->param('auto_renew'), switch_onsite_checkout => $switch_onsite_checkout, cancel_recall => $cancel_recall, recall_id => $recall_id, } );	403	my $issue = AddIssue( $patron, $barcode, $datedue, $cancelreserve, undef, undef, { onsite_checkout => $onsite_checkout, auto_renew => $session->param('auto_renew'), switch_onsite_checkout => $switch_onsite_checkout, cancel_recall => $cancel_recall, recall_id => $recall_id, } );
404	$template_params->{issue} = $issue;	404	$template_params->{issue} = $issue;
405	$session->clear('auto_renew');	405	$session->clear('auto_renew');
406	$inprocess = 1;	406	$inprocess = 1;





    my $branchcode = C4::Context->userenv->{branch};
    my $patron = Koha::Patrons->find( { cardnumber => $circ->{cardnumber} } );
    my $borrower = $patron->unblessed;
    my $item = Koha::Items->find({ barcode => $circ->{barcode} });
    my $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
    my $biblio = $item->biblio;

    if ( $issue ) { ## Item is currently checked out to another person.
        #warn "Item Currently Issued.";

        if ( $issue->borrowernumber eq $patron->borrowernumber ) { ## Issued to this person already, renew it.
            #warn "Item issued to this member already, renewing.";

            C4::Circulation::AddRenewal(

                title => $biblio->title,
                biblionumber => $biblio->biblionumber,
                barcode => $item->barcode,
                firstname => $patron->firstname,
                surname => $patron->surname,
                borrowernumber => $patron->borrowernumber,
                cardnumber => $patron->cardnumber,
                datetime => $circ->datetime
            };

        } else {

            my ( $c_y, $c_m, $c_d ) = split( /-/, $circ->{'date'} );

            if ( Date_to_Days( $i_y, $i_m, $i_d ) < Date_to_Days( $c_y, $c_m, $c_d ) ) { ## Current issue to a different persion is older than this issue, return and issue.
                C4::Circulation::AddIssue( $patron, $circ->{'barcode'}, undef, undef, $circ->{'date'} ) unless ( DEBUG );
                push @output, {
                    issue => 1,
                    title => $biblio->title,
                    biblionumber => $biblio->biblionumber,
                    barcode => $item->barcode,
                    firstname => $patron->firstname,
                    surname => $patron->surname,
                    borrowernumber => $patron->borrowernumber,
                    cardnumber => $patron->cardnumber,
                    datetime => $circ->datetime
                };

            } else { ## Current issue is *newer* than this issue, write a 'returned' issue, as the item is most likely in the hands of someone else now.

            }
        }
    } else { ## Item is not checked out to anyone at the moment, go ahead and issue it
        C4::Circulation::AddIssue( $patron, $circ->{'barcode'}, undef, undef, $circ->{'date'} ) unless ( DEBUG );
        push @output, {
            issue => 1,
            title => $biblio->title,
            biblionumber => $biblio->biblionumber,
            barcode => $item->barcode,
            firstname => $patron->firstname,
            surname => $patron->surname,
            borrowernumber => $patron->borrowernumber,
            cardnumber => $patron->cardnumber,
            datetime =>$circ->datetime
        };
    }
}

Lines 245-251 elsif ( $patron && ( $op eq 'checkout' ) ) { Link Here

(-)a/opac/sco/sco-main.pl (-1 / +1 lines)
245	)->count;	245	)->count;
246	}	246	}
247		247
248	AddIssue( $patron->unblessed, $barcode );	248	AddIssue( $patron, $barcode );
249	$template->param( issued => 1 );	249	$template->param( issued => 1 );
250	push @newissueslist, $barcode;	250	push @newissueslist, $barcode;
251		251

Lines 479-486 if ( ( $findborrower && $borrowernumber_hold \|\| $findclub && $club_hold ) Link Here

(-)a/reserve/request.pl (-2 / +1 lines)
479	}	479	}
480		480
481	if ( $patron ) {	481	if ( $patron ) {
482	my $patron_unblessed = $patron->unblessed;	482	my $branch = _GetCircControlBranch($item_object, $patron);
483	my $branch = C4::Circulation::_GetCircControlBranch($item, $patron_unblessed);
484		483
485	my $branchitemrule = GetBranchItemRule( $branch, $item->{'itype'} );	484	my $branchitemrule = GetBranchItemRule( $branch, $item->{'itype'} );
486		485




    my $checkout = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
    if ($checkout) {
        my $patron = Koha::Patrons->find( $checkout->borrowernumber );
        my $branchcode = C4::Circulation::_GetCircControlBranch( $item, $patron );
          C4::Circulation::_GetCircControlBranch( $item->unblessed,
            $patron->unblessed );
        $letter_params = {
            tables => {
                issues      => $item->itemnumber,

    my $patron = Koha::Patrons->find( $borrowernumber );
    if ($item and $patron) {
        my $branchcode =
          C4::Circulation::_GetCircControlBranch( $item, $patron );
            $patron->unblessed );
        $letter_params = {
            tables => {
                issues      => $item->itemnumber,




my $CircControl = C4::Context->preference('CircControl');
my $HomeOrHoldingBranch = C4::Context->preference('HomeOrHoldingBranch');

my $item = $builder->build_object({
    class => 'Koha::Items',
    value => {
        homebranch => $library2->{branchcode},
        holdingbranch => $library2->{branchcode}
    }
});

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

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


);
is(
    C4::Circulation::_GetCircControlBranch($item, $borrower),
    $item->get_column($HomeOrHoldingBranch),
    '_GetCircControlBranch returned item branch (no userenv defined)'
);


);
is(
    C4::Circulation::_GetCircControlBranch($item, $borrower),
    $borrower->branchcode,
    '_GetCircControlBranch returned borrower branch'
);


    'CircControl changed to ItemHomeLibrary'
);
is(
    $item->get_column($HomeOrHoldingBranch),
    C4::Circulation::_GetCircControlBranch($item, $borrower),
    '_GetCircControlBranch returned item branch'
);

);
is(
    C4::Circulation::_GetCircControlBranch($item, $borrower),
    $borrower->branchcode,
    '_GetCircControlBranch returned borrower branch'
);


);
is(
    C4::Circulation::_GetCircControlBranch($item, $borrower),
    $item->get_column($HomeOrHoldingBranch),
    '_GetCircControlBranch returned item branch'
);


        homebranch   => $patron_hold_1->branchcode
    });

    my $issue = AddIssue( $patron, $item_1->barcode);
    my $datedue = dt_from_string( $issue->date_due() );
    is (defined $issue->date_due(), 1, "Item 1 checked out, due date: " . $issue->date_due() );


    my $checkitem      = undef;
    my $found          = undef;

    my $issue_1 = AddIssue( $renewing_borrower_obj, $item_1->barcode);
    my $datedue = dt_from_string( $issue_1->date_due() );
    is (defined $issue_1->date_due(), 1, "Item 1 checked out, due date: " . $issue_1->date_due() );

    my $issue_2 = AddIssue( $renewing_borrower_obj, $item_2->barcode);
    is (defined $issue_2, 1, "Item 2 checked out, due date: " . $issue_2->date_due());

    my $borrowing_borrowernumber = Koha::Checkouts->find( { itemnumber => $item_1->itemnumber } )->borrowernumber;

    is( $error, 'on_reserve', '(Bug 10663) Cannot renew, reserved (returned error is on_reserve)');

    my $reserveid = Koha::Holds->search({ biblionumber => $biblio->biblionumber, borrowernumber => $reserving_borrowernumber })->next->reserve_id;
    my $reserving_borrower = Koha::Patrons->find( $reserving_borrowernumber );
    AddIssue($reserving_borrower, $item_3->barcode);
    my $reserve = $dbh->selectrow_hashref(
        'SELECT * FROM old_reserves WHERE reserve_id = ?',

            itype            => $itemtype,
        }
    );
    my $issue_5 = AddIssue($restricted_borrower_obj, $item_5->barcode);
    is (defined $issue_5, 1, "Item with date due checked out, due date: ". $issue_5->date_due);

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

        }
    );

    my $issue_6 = AddIssue( $renewing_borrower_obj, $item_6->barcode);
    is (defined $issue_6, 1, "Item 2 checked out, due date: ".$issue_6->date_due);

    my $now = dt_from_string();

    my $five_weeks_ago = $now - $five_weeks;
    t::lib::Mocks::mock_preference('finesMode', 'production');

    my $issue_7 = AddIssue($renewing_borrower_obj, $item_7->barcode, $five_weeks_ago);
    is (defined $issue_7, 1, "Item with passed date due checked out, due date: " . $issue_7->date_due);

    t::lib::Mocks::mock_preference('OverduesBlockRenewing','allow');

    my $old_issue_log_size = Koha::ActionLogs->count( \%params_issue );
    my $old_renew_log_size = Koha::ActionLogs->count( \%params_renewal );
    AddIssue(
        $renewing_borrower_obj,
        $item_7->barcode,
        Koha::DateUtils::output_pref({str=>$issue_6->date_due, dateformat =>'iso'}),
        0,

        }
    );

    my $issue_4 = AddIssue( $renewing_borrower_obj, $item_4->barcode, undef, undef, undef, undef, { auto_renew => 1 } );
    my $info;
    ( $renewokay, $error, $info ) =
      CanBookBeRenewed( $renewing_borrower_obj, $issue_4 );


        my $ten_days_before = dt_from_string->add( days => -10 );
        my $ten_days_ahead  = dt_from_string->add( days => 10 );
        my $issue = AddIssue( $renewing_borrower_obj, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );

        Koha::CirculationRules->set_rules(
            {


        my $ten_days_before = dt_from_string->add( days => -10 );
        my $ten_days_ahead = dt_from_string->add( days => 10 );
        my $issue = AddIssue( $renewing_borrower_obj, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );

        Koha::CirculationRules->set_rules(
            {

        # Patron is expired and BlockExpiredPatronOpacActions=0
        # => auto renew is allowed
        t::lib::Mocks::mock_preference('BlockExpiredPatronOpacActions', 0);
        my $issue = AddIssue( $expired_borrower_obj, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
        ( $renewokay, $error ) =
          CanBookBeRenewed( $expired_borrower_obj, $issue );
        is( $renewokay, 0, 'Do not renew, renewal is automatic' );

        # Patron is expired and BlockExpiredPatronOpacActions=1
        # => auto renew is not allowed
        t::lib::Mocks::mock_preference('BlockExpiredPatronOpacActions', 1);
        $issue = AddIssue( $expired_borrower_obj, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
        ( $renewokay, $error ) =
          CanBookBeRenewed( $expired_borrower_obj, $issue );
        is( $renewokay, 0, 'Do not renew, renewal is automatic' );

        # Patron is not expired and BlockExpiredPatronOpacActions=1
        # => auto renew is allowed
        t::lib::Mocks::mock_preference('BlockExpiredPatronOpacActions', 1);
        $issue = AddIssue( $renewing_borrower_obj, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
        ( $renewokay, $error ) =
          CanBookBeRenewed( $renewing_borrower_obj, $issue );
        is( $renewokay, 0, 'Do not renew, renewal is automatic' );


        my $ten_days_before = dt_from_string->add( days => -10 );
        my $ten_days_ahead  = dt_from_string->add( days => 10 );
        my $issue = AddIssue( $renewing_borrower_obj, $item_to_auto_renew->barcode, $ten_days_ahead, undef, $ten_days_before, undef, { auto_renew => 1 } );
        Koha::CirculationRules->set_rules(
            {
                categorycode => undef,

    my $recall_item1 = $builder->build_sample_item({ biblionumber => $recall_biblio->biblionumber });
    my $recall_item2 = $builder->build_sample_item({ biblionumber => $recall_biblio->biblionumber });

    my $recall_issue = AddIssue( $renewing_borrower_obj, $recall_item1->barcode );

    # item-level and this item: renewal not allowed
    my $recall = Koha::Recall->new({

    );

    my $a_borrower_borrowernumber = Koha::Patron->new(\%a_borrower_data)->store->borrowernumber;
    my $a_borrower = Koha::Patrons->find( $a_borrower_borrowernumber );

    my $yesterday = DateTime->today(time_zone => C4::Context->tz())->add( days => -1 );
    my $two_days_ahead = DateTime->today(time_zone => C4::Context->tz())->add( days => 2 );


    my $borrowernumber = Koha::Patron->new(\%a_borrower_data)->store->borrowernumber;

    my $borrower = Koha::Patrons->find( $borrowernumber );
    my $issue = AddIssue( $borrower, $item->barcode );
    UpdateFine(
        {

        branchcode => $branch,
    })->store;

    my $issue = AddIssue( $borrower, $item->barcode, undef, undef, undef, undef, { onsite_checkout => 1 } );
    my ( $renewed, $error ) = CanBookBeRenewed( $borrower, $issue );
    is( $renewed, 0, 'CanBookBeRenewed should not allow to renew on-site checkout' );
    is( $error, 'onsite_checkout', 'A correct error code should be returned by CanBookBeRenewed for on-site checkout' );

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

    my $issue = AddIssue( $patron, $item->barcode );
    UpdateFine(
        {
            issue_id       => $issue->id,


    set_userenv($holdingbranch);

    my $issue = AddIssue( $patron_1, $item->barcode );
    is( ref($issue), 'Koha::Checkout', 'AddIssue should return a Koha::Checkout object' );

    my ( $error, $question, $alerts );

    my $homebranch    = $builder->build( { source => 'Branch' } );
    my $holdingbranch = $builder->build( { source => 'Branch' } );
    my $otherbranch   = $builder->build( { source => 'Branch' } );

    my $patron_1  = $builder->build_object({
        class => 'Koha::Patrons',
        value => { categorycode => $patron_category->{categorycode} }
    });

    my $patron_2  = $builder->build_object({
        class => 'Koha::Patrons',
        value => { categorycode => $patron_category->{categorycode} }
    });


    my $item = $builder->build_sample_item(
        {

        }
    );

    my $issue = AddIssue( $patron, $item->barcode, $five_days_go ); # date due was 10d ago
    my $actualissue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
    is( output_pref({ str => $actualissue->date_due, dateonly => 1}), output_pref({ str => $five_days_go, dateonly => 1}), "First issue works");
    my ($issuingimpossible, $needsconfirmation) = CanBookBeIssued($patron, $item->barcode, $ten_days_go, undef, undef, undef);

    });

    # this item can fill a recall with pickup at this branch
    AddIssue( $patron1, $item1->barcode );
    my $recall1 = Koha::Recall->new(
        {   patron_id         => $patron2->borrowernumber,
            biblio_id         => $item1->biblionumber,

    $recall1->set_cancelled;

    # this item can fill a recall but needs transfer
    AddIssue( $patron1, $item1->barcode );
    $recall1 = Koha::Recall->new(
        {   patron_id         => $patron2->borrowernumber,
            biblio_id         => $item1->biblionumber,

    $recall1->set_cancelled;

    # this item is already in transit, do not ask to transfer
    AddIssue( $patron1, $item1->barcode );
    $recall1 = Koha::Recall->new(
        {   patron_id         => $patron2->borrowernumber,
            biblio_id         => $item1->biblionumber,

    $context->mock( userenv => { branch => $library->id } );

    # Check the item out
    AddIssue( $patron, $item->barcode );

    throws_ok {
        AddRenewal( $patron->borrowernumber, $item->itemnumber, $library->id, undef, {break=>"the_renewal"} );

    is( $new_stats_size, $old_stats_size + 1, 'renew statistic successfully added with passed branch' );

    AddReturn( $item->id, $library->id, undef, $date );
    AddIssue( $patron, $item->barcode, $now );
    AddRenewal( $patron->id, $item->id, $library->id, undef, undef, 1 );
    my $lines_skipped = Koha::Account::Lines->search({
        borrowernumber => $patron->id,

    set_userenv( $library->unblessed );

    # Check the item out
    my $issue = AddIssue( $patron, $item->barcode );
    is(ref($issue), 'Koha::Checkout', 'Issue added');

    # Renew item


    # Daily Tests
    my $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    my $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
    is(
        $accountline->amount + 0,

    t::lib::Mocks::mock_preference( 'finesCalendar', 'noFinesWhenClosed' );
    $itemtype->rentalcharge_daily_calendar(1)->store();
    $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
    is(
        $accountline->amount + 0,

        description => 'Test holiday'
    );
    $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
    is(
        $accountline->amount + 0,

    $itemtype->rentalcharge(2)->store;
    is( $itemtype->rentalcharge + 0, 2, 'Rental charge updated and retreived correctly' );
    $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    my $accountlines =
      Koha::Account::Lines->search( { itemnumber => $item->id } );
    is( $accountlines->count, '2', "Fixed charge and accrued charge recorded distinctly" );


    $itemtype->rentalcharge_hourly_calendar(0)->store();
    $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
    is(
        $accountline->amount + 0,


    $itemtype->rentalcharge_hourly_calendar(1)->store();
    $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
    is(
        $accountline->amount + 0,


    $calendar->delete_holiday( weekday => $closed_day );
    $issue =
      AddIssue( $patron, $item->barcode, $dt_to, undef, $dt_from );
    $accountline = Koha::Account::Lines->find( { itemnumber => $item->id } );
    is(
        $accountline->amount + 0,

    );

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

    my $accountline = Koha::Account::Line->new(
        {

    )->store();

    # AddRenewal doesn't call _FixAccountForLostAndFound
    AddIssue( $patron, $item->barcode );

    is( $patron->checkouts->count, 1,
        'Renewal should not return the item even if a LOST payment has been made earlier'

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

        )->next;
        ok( $a, "Found accountline for lost fee" );
        is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
        $issue = AddIssue( $patron2, $item->barcode );
        $a = $a->get_from_storage;
        is( $a->amountoutstanding + 0, 0, "Lost fee was refunded" );
        $a->delete;

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

        )->next;
        ok( $a, "Found accountline for lost fee" );
        is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
        $issue = AddIssue( $patron2, $item->barcode );
        $a = $a->get_from_storage;
        is( $a->amountoutstanding + 0, 0, "Lost fee was refunded" );
        $a->delete;

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

        )->next;
        ok( $a, "Found accountline for lost fee" );
        is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
        $issue = AddIssue( $patron2, $item->barcode );
        $a = $a->get_from_storage;
        is( $a->amountoutstanding + 0, 42, "Lost fee was not refunded" );
        $a->delete;

                replacementprice => '42',
            }
        );
        my $issue = AddIssue( $patron, $item->barcode );
        LostItem( $item->itemnumber, 'cli', 0 );
        $item->_result->itemlost(1);
        $item->_result->itemlost_on( $lost_on );

        $a = $a->next;
        ok( $a, "Found accountline for lost fee" );
        is( $a->amountoutstanding + 0, 42, "Lost fee charged correctly" );
        $issue = AddIssue( $patron2, $item->barcode );
        $a = $a->get_from_storage;
        is( $a->amountoutstanding + 0, 42, "Lost fee was not refunded" );
        $a->delete;

    is( $transfer->reason,     'Reserve' );

    t::lib::Mocks::mock_userenv( { branchcode => $library_2->branchcode } );
    AddIssue( $patron_1, $item->barcode );
    $transfer = $transfer->get_from_storage;
    isnt( $transfer->datearrived, undef );
    $hold = $hold->get_from_storage;

    my $dt_from = dt_from_string();
    my $dt_to   = dt_from_string()->add( days => 7 );

    my $issue_1 = AddIssue( $patron, $item_1->barcode, $dt_to, undef, $dt_from );

    is( $issue_1->issuer, undef, "Staff who checked out the item not recorded when RecordStaffUserOnCheckout turned off" );

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

    my $issue_2 =
      AddIssue( $patron, $item_2->barcode, $dt_to, undef, $dt_from );

    is( $issue_2->issuer->borrowernumber, $issuer->borrowernumber, "Staff who checked out the item recorded when RecordStaffUserOnCheckout turned on" );
};

        }
    );

    AddIssue( $patron_1, $item->barcode );
    ok( $item->get_from_storage->onloan, "Item's onloan column is set after initial checkout" );
    AddIssue( $patron_2, $item->barcode );
    ok( $item->get_from_storage->onloan, "Item's onloan column is set after second checkout" );
};


    })->store;

    # Checkout an item, mark it returned, generate a notice
    my $issue_1 = AddIssue( $patron, $item->barcode);
    MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0, { skip_record_index => 1} );
    C4::Circulation::SendCirculationAlert({
        type => 'CHECKIN',

    is($notice->to_address, $patron->smsalertnumber, "Letter has the correct to_address set to smsalertnumber for SMS type notices");

    # Checkout an item, mark it returned, generate a notice
    my $issue_2 = AddIssue( $patron, $item->barcode);
    MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0, { skip_record_index => 1} );
    C4::Circulation::SendCirculationAlert({
        type => 'CHECKIN',

        }
    );
    my $item = $builder->build_sample_item();
    my $issue = AddIssue( $patron, $item->barcode);
    my $datedue = dt_from_string( $issue->date_due() );

    # Bug 14395




$schema->storage->txn_begin;
my $builder = t::lib::TestBuilder->new;


my $library = $builder->build_object({ class => 'Koha::Libraries' })->store;
my $dateexpiry = '2013-01-01';
my $patron_category = $builder->build_object({ class => 'Koha::Patron::Categories', value => { category_type => 'B' } })->store;
my $borrower = $builder->build_object(
    {
        class  => 'Koha::Patrons',
        value  => {
            categorycode => $patron_category->categorycode,
            dateexpiry => $dateexpiry,
        }
    }
)->store;

my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
my $issuelength = 10;
my $renewalperiod = 5;
my $lengthunit = 'days';

Koha::CirculationRules->search()->delete();
Koha::CirculationRules->set_rules(
    {
        categorycode => $patron_category->categorycode,
        itemtype     => $itemtype,
        branchcode   => $library->branchcode,
        rules        => {
            issuelength   => $issuelength,
            renewalperiod => $renewalperiod,

t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 1);
t::lib::Mocks::mock_preference('useDaysMode', 'Days');

my $branchcode = $library->branchcode;

my $cache = Koha::Caches->get_instance();
my $key   = $branchcode . "_holidays";
$cache->clear_from_cache($key);

my $dateexpiry = '2013-01-01';

my $borrower = {categorycode => 'B', dateexpiry => $dateexpiry};
my $start_date = DateTime->new({year => 2013, month => 2, day => 9});
my $date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );
is($date, $dateexpiry . 'T23:59:00', 'date expiry');

t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 1);
t::lib::Mocks::mock_preference('useDaysMode', 'noDays');

$borrower = {categorycode => 'B', dateexpiry => $dateexpiry};
$start_date = DateTime->new({year => 2013, month => 2, day => 9});
$date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );
is($date, $dateexpiry . 'T23:59:00', 'date expiry with useDaysMode to noDays');

t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 0);
t::lib::Mocks::mock_preference('useDaysMode', 'Days');

$borrower = {categorycode => 'B', dateexpiry => $dateexpiry};
$start_date = DateTime->new({year => 2013, month => 2, day => 9});
$date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );
is($date, '2013-02-' . (9 + $issuelength) . 'T23:59:00', "date expiry ( 9 + $issuelength )");


# Now we test it does the right thing if the loan and renewal periods
# are a multiple of 7 days
my $dayweek_categorycode = 'K';
my $dayweek_itemtype = 'MX';
my $dayweek_branchcode = 'FPL';
my $dayweek_issuelength = 14;
my $dayweek_renewalperiod = 7;
my $dayweek_lengthunit = 'days';

$patron_category = $builder->build_object({ class => 'Koha::Patron::Categories', value => { category_type => 'K' } })->store;

Koha::CirculationRules->set_rules(
    {
        categorycode => $patron_category->categorycode,
        itemtype     => $itemtype,
        branchcode   => $branchcode,
        rules        => {
            issuelength   => $dayweek_issuelength,
            renewalperiod => $dayweek_renewalperiod,

    }
);

my $dayweek_borrower = $builder->build_object(
    {
        class  => 'Koha::Patrons',
        value  => {
            categorycode => $patron_category->categorycode,
            dateexpiry => $dateexpiry,
        }
    }
);

# For issues...
$start_date = DateTime->new({year => 2013, month => 2, day => 9});




my $barcode2 = '0202';
Koha::Item->new({ barcode => $barcode2, %item_info, biblionumber => $biblionumber2 })->store;

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

my $borrowernumber1 = $patron1->borrowernumber;
my $borrowernumber2 = $patron2->borrowernumber;

my $module = Test::MockModule->new('C4::Context');
$module->mock('userenv', sub { { branch => $branchcode } });

$check_if_issued = C4::Circulation::CheckIfIssuedToPatron($borrowernumber2, $biblionumber2);
is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' );

AddIssue($patron1, '0101');
$check_if_issued = C4::Circulation::CheckIfIssuedToPatron();
is( $check_if_issued, undef, 'CheckIfIssuedToPatron without argument returns undef' );
$check_if_issued = C4::Circulation::CheckIfIssuedToPatron(undef, $biblionumber1);

$check_if_issued = C4::Circulation::CheckIfIssuedToPatron($borrowernumber2, $biblionumber2);
is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' );

AddIssue($patron2, '0202');
$check_if_issued = C4::Circulation::CheckIfIssuedToPatron();
is( $check_if_issued, undef, 'CheckIfIssuedToPatron without argument returns undef' );
$check_if_issued = C4::Circulation::CheckIfIssuedToPatron(undef, $biblionumber1);




my $itemnumber3 = Koha::Item->new({ barcode => '0203', %item_infos, biblionumber => $biblionumber2})->store->itemnumber;

my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };
my $patron = $builder->build_object(
    {   class => 'Koha::Patrons',
        value  => { categorycode => $categorycode, branchcode => $branchcode }
    }
);

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

# Need to mock userenv for AddIssue
my $module = Test::MockModule->new('C4::Context');
$module->mock('userenv', sub { { branch => $branchcode } });
AddIssue($patron, '0101');
AddIssue($patron, '0203');

# Begin tests...
my $onsite_checkouts = GetPendingOnSiteCheckouts;
is( scalar @$onsite_checkouts, 0, "No pending on-site checkouts" );

my $itemnumber4 = Koha::Item->new({ barcode => '0104', %item_infos, biblionumber => $biblionumber1})->store->itemnumber;
AddIssue( $patron, '0104', undef, undef, undef, undef, { onsite_checkout => 1 } );
$onsite_checkouts = GetPendingOnSiteCheckouts;
is( scalar @$onsite_checkouts, 1, "There is 1 pending on-site checkout" );


Lines 68-74 my $borrowernumber = Koha::Patron->new({ Link Here

(-)a/t/db_dependent/Circulation/GetTopIssues.t (-1 / +1 lines)
68	categorycode => $category,	68	categorycode => $category,
69	branchcode => $branch_1->{ branchcode }	69	branchcode => $branch_1->{ branchcode }
70	})->store->borrowernumber;	70	})->store->borrowernumber;
71	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;	71	my $borrower = Koha::Patrons->find( $borrowernumber );
72		72
73	AddIssue($borrower, 'GTI_BARCODE_001');	73	AddIssue($borrower, 'GTI_BARCODE_001');
74	AddIssue($borrower, 'GTI_BARCODE_002');	74	AddIssue($borrower, 'GTI_BARCODE_002');





t::lib::Mocks::mock_userenv({ branchcode => $library->{branchcode} });

my $borrower = Koha::Patron->new({
    firstname =>  'my firstname',
    surname => 'my surname',
    categorycode => $patron_category->{categorycode},
    branchcode => $library->{branchcode},
})->store;


my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;
my $record = MARC::Record->new();
my ( $biblionumber, $biblioitemnumber ) = AddBiblio( $record, '' );





    is( $issue_id, undef, 'No issue_id returned' );

    # In the next call we return the item and try it another time
    $issue = C4::Circulation::AddIssue( $patron, $item->barcode );
    eval { $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0 ) };
    is( $issue_id, $issue->issue_id, "Item has been returned (issue $issue_id)" );
    eval { $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0 ) };

    # Anonymous patron not set
    t::lib::Mocks::mock_preference( 'AnonymousPatron', '' );

    my $issue = C4::Circulation::AddIssue( $patron, $item->barcode );

    throws_ok
        { C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 2 ); }

        }
    });
    t::lib::Mocks::mock_preference('AnonymousPatron', $anonymous->borrowernumber);
    $issue = C4::Circulation::AddIssue( $patron, $item->barcode );

    eval { C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 2 ) };
    is ( $@, q||, 'AnonymousPatron is set correctly - no error expected');


    my ( $issue, $issue_id );

    $issue = C4::Circulation::AddIssue( $patron, $item->barcode );
    $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, '2018-12-25', 0 );

    is( $issue_id, $issue->issue_id, "Item has been returned" );
    my $old_checkout = Koha::Old::Checkouts->find( $issue_id );
    is( $old_checkout->returndate, '2018-12-25 00:00:00', 'Manually passed date stored correctly' );

    $issue = C4::Circulation::AddIssue( $patron, $item->barcode );

    {
        # Hiding the expected warning displayed by DBI

    my $item_2 = $builder->build_sample_item;
    my $item_3 = $builder->build_sample_item;
    my $five_days_ago = dt_from_string->subtract( days => 5 );
    my $checkout_1 = AddIssue( $patron, $item_1->barcode, $five_days_ago ); # overdue
    my $checkout_2 = AddIssue( $patron, $item_2->barcode, $five_days_ago ); # overdue
    my $checkout_3 = AddIssue( $patron, $item_3->barcode ); # not overdue

    Koha::Patron::Debarments::AddUniqueDebarment(
        {




    t::lib::Mocks::mock_preference( 'MarkLostItemsAsReturned', q{} );
    my $item   = $builder->build_sample_item;
    my $patron   = $builder->build_object( { class => 'Koha::Patrons' } );
    my $checkout = AddIssue( $patron, $item->barcode );

    my $claim = $checkout->claim_returned(
        {

    t::lib::Mocks::mock_preference( 'ClaimReturnedLostValue', 1 );
    my $item   = $builder->build_sample_item;
    my $patron   = $builder->build_object( { class => 'Koha::Patrons' } );
    my $checkout = AddIssue( $patron, $item->barcode );

    $checkout->claim_returned(
        {

    t::lib::Mocks::mock_preference( 'MarkLostItemsAsReturned', q{claim_returned} );
    my $item     = $builder->build_sample_item;
    my $patron   = $builder->build_object( { class => 'Koha::Patrons' } );
    my $checkout = AddIssue( $patron, $item->barcode );

    my $claim = $checkout->claim_returned(
        {




    # Create a branch
    $branch = $builder->build({ source => 'Branch' })->{ branchcode };
    # Create a borrower
    my $patron = $builder->build_object({
        class => 'Koha::Patrons',
        value => { branchcode => $branch }
    });
    # Look for the defined MARC field for biblio-level itemtype
    my $rs = $schema->resultset('MarcSubfieldStructure')->search({
        frameworkcode => '',

        }
    )->_result->update({ itype => undef });

    AddIssue( $patron, $item_with_itemtype->barcode );
    AddIssue( $borrower, $item_with_itemtype->barcode );
    AddReturn( $item_with_itemtype->barcode, $branch );
    # Test item-level itemtype was recorded on the 'statistics' table
    my $stat = $schema->resultset('Statistic')->search({


    is( $stat->itemtype, $ilevel_itemtype,
        "item-level itype recorded on statistics for return");
    warning_like { AddIssue( $patron, $item_without_itemtype->barcode ) }
                 [qr/^item-level_itypes set but no itemtype set for item/,
                 qr/^item-level_itypes set but no itemtype set for item/,
                 qr/^item-level_itypes set but no itemtype set for item/],
                 'Item without itemtype set raises warning on AddIssue';
    AddReturn( $item_without_itemtype->barcode, $branch );

    # Create a branch
    $branch = $builder->build({ source => 'Branch' })->{ branchcode };
    # Create a borrower
    my $patron = $builder->build_object({
        class => 'Koha::Patrons',
        value => { branchcode => $branch }
    })->{ borrowernumber };
    # Look for the defined MARC field for biblio-level itemtype

        }
    );

    AddIssue( $patron, $item_with_itemtype->barcode );

    AddIssue( $borrower, $item_with_itemtype->barcode );
    AddReturn( $item_with_itemtype->barcode, $branch );
    # Test item-level itemtype was recorded on the 'statistics' table
    my $stat = $schema->resultset('Statistic')->search({

    is( $stat->itemtype, $blevel_itemtype,
        "biblio-level itype recorded on statistics for return");

    AddIssue( $patron, $item_without_itemtype->barcode );
    AddReturn( $item_without_itemtype->barcode, $branch );
    # Test biblio-level itemtype was recorded on the 'statistics' table
    $stat = $schema->resultset('Statistic')->search({

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

    my $original_checkout = AddIssue( $patron, $item->barcode, dt_from_string->subtract( days => 50 ) );
    my $issue_id = $original_checkout->issue_id;
    my $account_lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber, issue_id => $issue_id });
    is( $account_lines->count, 1, '1 account line should exist for this issue_id' );

    is( $messages->{WasReturned}, 0, 'messages should have the WasReturned flag set to 0' );
    is( $messages->{DataCorrupted}, 1, 'messages should have the DataCorrupted flag set to 1' );

    $account_lines = Koha::Account::Lines->search({ borrowernumber => $borrower->{borrowernumber}, issue_id => $issue_id });
    is( $account_lines->count, 0, 'No account lines should exist for this issue_id, patron should not have been charged' );

    is( Koha::Checkouts->find( $issue_id )->issue_id, $issue_id, 'The issues entry should not have been removed' );

subtest 'BlockReturnOfLostItems' => sub {
    plan tests => 4;
    my $item = $builder->build_sample_item;
    my $patron = $builder->build_object({ class => 'Koha::Patrons' });
    my $checkout = AddIssue( $patron, $item->barcode );

    # Mark the item as lost
    $item->itemlost(1)->store;

    t::lib::Mocks::mock_preference('ClaimReturnedLostValue', 1);
    my $item = $builder->build_sample_item;
    my $patron = $builder->build_object({class => 'Koha::Patrons'});
    my $checkout = AddIssue( $patron, $item->barcode );

    $checkout->claim_returned({ created_by => $patron->id });



    my $item = $builder->build_sample_item;
    my $patron = $builder->build_object({class => 'Koha::Patrons'});
    my $checkout = AddIssue( $patron, $item->barcode );
    my ( $doreturn, $messages, $issue ) = AddReturn($item->barcode);
    is( $doreturn, 1, 'AddReturn should have checkin the item if BranchTransferLimitsType=ccode');

    t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');
    $checkout = AddIssue( $patron, $item->barcode );
    ( $doreturn, $messages, $issue ) = AddReturn($item->barcode);
    is( $doreturn, 1, 'AddReturn should have checkin the item if BranchTransferLimitsType=itemtype');
};

    my $biblio = $builder->build_object( { class => 'Koha::Biblios' } );
    my $item = $builder->build_sample_item;
    my $patron = $builder->build_object({class => 'Koha::Patrons'});
    my $checkout = AddIssue( $patron, $item->barcode );
    my $fine = Koha::Account::Line->new({
        issue_id => $checkout->id,
        borrowernumber => $patron->id,




        categorycode => $patron_category->{categorycode},
    },
});
my $patron_unblessed = $patron->unblessed;

my $item = $builder->build_sample_item(
    {

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

# Add onsite checkout
C4::Circulation::AddIssue( $patron, $item->barcode, dt_from_string, undef, dt_from_string, undef, { onsite_checkout => 1 } );

my ( $impossible, $messages );
t::lib::Mocks::mock_preference('SwitchOnSiteCheckouts', 0);

( $impossible, undef, undef, $messages ) = C4::Circulation::CanBookBeIssued( $patron, $item->barcode );
is( $messages->{ONSITE_CHECKOUT_WILL_BE_SWITCHED}, 1, 'If SwitchOnSiteCheckouts, switch the on-site checkout' );
is( exists $impossible->{TOO_MANY}, '', 'If SwitchOnSiteCheckouts, switch the on-site checkout' );
C4::Circulation::AddIssue( $patron, $item->barcode, undef, undef, undef, undef, { switch_onsite_checkout => 1 } );
my $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
is( $issue->onsite_checkout, 0, 'The issue should have been switched to a regular checkout' );
my $five_days_after = dt_from_string->add( days => 5 )->set( hour => 23, minute => 59, second => 0 );

    }
);

C4::Circulation::AddIssue( $patron, $another_item->barcode, dt_from_string, undef, dt_from_string, undef, { onsite_checkout => 1 } );
( $impossible, undef, undef, $messages ) = C4::Circulation::CanBookBeIssued( $patron, $another_item->barcode );
is( $messages->{ONSITE_CHECKOUT_WILL_BE_SWITCHED}, 1, 'Specific case 1 - Switch is allowed' );
is( exists $impossible->{TOO_MANY}, '', 'Specific case 1 - Switch is allowed' );




$dbh->do(q|DELETE FROM issues|);
$dbh->do(q|DELETE FROM items|);
$dbh->do(q|DELETE FROM borrowers|);
#$dbh->do(q|DELETE FROM branches|);
$dbh->do(q|DELETE FROM categories|);
$dbh->do(q|DELETE FROM accountlines|);
$dbh->do(q|DELETE FROM itemtypes|);

    source => 'Category',
});

my $patron = $builder->build_object({
    class => 'Koha::Patrons',
    value => {
        categorycode => $category->{categorycode},
        branchcode => $branch->{branchcode},

    holdingbranch => $branch->{branchcode},
});

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

# TooMany return ($current_loan_count, $max_loans_allowed) or undef
# CO = Checkout

            notforloan => 0,
        }
    });
    my $patron = $builder->build_object({
        class => 'Koha::Patrons',
        value => {
            categorycode => $category->{categorycode},
            branchcode => $branch->{branchcode},


    my $branch   = $builder->build( { source => 'Branch', } );
    my $category = $builder->build( { source => 'Category', } );
    my $patron   = $builder->build_object(
        {
            class => 'Koha::Patrons',
            value  => {
                categorycode => $category->{categorycode},
                branchcode   => $branch->{branchcode},





    # this triggers the compare between expiry and due date

    my $patron = $builder->build_object(
        {
            class  => 'Koha::Patrons',
            value  => {
                categorycode => $patron_category->{categorycode},
            }
        }
    );
    my $item   = $builder->build_sample_item;
    my $branch = $builder->build( { source => 'Branch' } );
    my $today  = dt_from_string();

    # first test with empty expiry date
    # note that this expiry date will never lead to an issue btw !!
    $patron->dateexpiry(undef)->store;
    my $d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
    is( ref $d eq "DateTime" && $d->mdy() =~ /^\d+/, 1, "CalcDateDue with expiry undef" );

    # second test expiry date==today
    my $d2 = output_pref( { dt => $today, dateonly => 1, dateformat => 'sql' } );
    $patron->dateexpiry($d2)->store;
    $d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
    is( ref $d eq "DateTime" && DateTime->compare( $d->truncate( to => 'day' ), $today->truncate( to => 'day' ) ) == 0, 1, "CalcDateDue with expiry today" );


    my $dur = DateTime::Duration->new( days => 1 );
    my $tomorrow = $today->clone->add_duration($dur);
    $d2 = output_pref( { dt => $tomorrow, dateonly => 1, dateformat => 'sql' } );
    $patron->dateexpiry($d2)->store;
    $d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
    is( ref $d eq "DateTime" && $d->mdy() =~ /^\d+/, 1, "CalcDateDue with expiry tomorrow" );

    # fourth test far future
    $patron->dateexpiry('9876-12-31')->store;
    my $t1 = time;
    $d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
    my $t2 = time;




    branchcode   => $branchcode_1
})->store->borrowernumber;
my $patron_1 = Koha::Patrons->find( $borrower_id1 );
my $borrower_1 = $patron_1->unblessed;
my $borrower_id2 = Koha::Patron->new({
    firstname    => 'firstname2',
    surname      => 'surname2 ',

    branchcode   => $branchcode_2,
})->store->borrowernumber;
my $patron_2 = Koha::Patrons->find( $borrower_id2 );
my $borrower_2 = $patron_2->unblessed;

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


my $query = " SELECT count(*) FROM issues";
my $sth = $dbh->prepare($query);
$sth->execute;
my $countissue = $sth->fetchrow_array;
is ($countissue ,0, "there is no issue");
my $issue1 = C4::Circulation::AddIssue( $patron_1, $barcode_1, $daysago10, 0, $today, '' );
is( ref $issue1, 'Koha::Checkout',
       'AddIssue returns a Koha::Checkout object' );
my $datedue1 = dt_from_string( $issue1->date_due() );

);
my $issue_id1 = $issue1->issue_id;

my $issue2 = C4::Circulation::AddIssue( $patron_1, 'nonexistent_barcode' );
is( $issue2, undef, "AddIssue returns undef if no datedue is specified" );

$sth->execute;
$countissue = $sth->fetchrow_array;
is ($countissue,1,"1 issues have been added");

#Test AddIssuingCharge

            my $item = $builder->build_sample_item(
                { library => $item_library->branchcode, itype => $itemtype } );
            my $opac_renew_issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            AddRenewal( $patron->borrowernumber, $item->itemnumber,
                "Stavromula", $datedue1, $daysago10 );

            my $item = $builder->build_sample_item(
                { library => $item_library->branchcode, itype => $itemtype } );
            my $opac_renew_issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            AddRenewal( $patron->borrowernumber, $item->itemnumber,
                "Stavromula", $datedue1, $daysago10 );


my @renewcount;
#Test GetRenewCount
my $issue3 = C4::Circulation::AddIssue( $patron_1, $barcode_1 );
#Without anything in DB
@renewcount = C4::Circulation::GetRenewCount();
is_deeply(

ok( $return->{return_date} eq $return->{today}, "Item returned with no return date specified has todays date" );

$dbh->do("DELETE FROM old_issues");
C4::Circulation::AddIssue( $patron_1, $barcode_1, $daysago10, 0, $today );
AddReturn($barcode_1, undef, undef, dt_from_string('2014-04-01 23:42'));
$return = $dbh->selectrow_hashref("SELECT * FROM old_issues LIMIT 1" );
ok( $return->{returndate} eq '2014-04-01 23:42:00', "Item returned with a return date of '2014-04-01 23:42' has that return date" );

ok( $item2->location eq 'CART', q{UpdateItemLocationOnCheckin updates location value from 'GEN' with setting "_ALL_: CART" when transfer filled} );

ok( $item2->permanent_location eq 'GEN', q{UpdateItemLocationOnCheckin does not update permanent_location value from 'GEN' with setting "_ALL_: CART"} );
AddIssue( $patron_1, 'barcode_4', $daysago10,0, $today, '' );
$item2 = Koha::Items->find( $itemnumber2 );
ok( $item2->location eq 'GEN', q{Location updates from 'CART' to permanent location on issue} );


    }
);
ok( $reserve_id, 'The reserve should have been inserted' );
AddIssue( $patron_2, $barcode_1, dt_from_string, 'cancel' );
my $hold = Koha::Holds->find( $reserve_id );
is( $hold, undef, 'The reserve should have been correctly cancelled' );


my $unseen_patron  = $builder->build_object( { class => 'Koha::Patrons' } );
my $unseen_item = $builder->build_sample_item(
    { library => $unseen_library->branchcode, itype => $itemtype } );
my $unseen_issue = C4::Circulation::AddIssue( $unseen_patron, $unseen_item->barcode );

# Does an unseen renewal increment the issue's count
my ( $unseen_before ) = ( C4::Circulation::GetRenewCount( $unseen_patron->borrowernumber, $unseen_item->itemnumber ) )[3];




    }
);

my $patron = Koha::Patron->new({
    firstname =>  'my firstname',
    surname => 'my surname',
    categorycode => $patron_category->{categorycode},
    branchcode => $branchcode,
})->store;
my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;

my $record = MARC::Record->new();
$record->append_fields(

my $daysago20 = dt_from_string->add_duration(DateTime::Duration->new(days => -20));
my $daysafter40 = dt_from_string->add_duration(DateTime::Duration->new(days => 40));

AddIssue( $patron, $barcode, $daysago20 );
AddReturn( $barcode, $branchcode );
my $debarments = GetDebarments({borrowernumber => $patron->borrowernumber});
is(
    $debarments->[0]->{expiration},
    output_pref({ dt => $daysafter40, dateformat => 'iso', dateonly => 1 }),

);

my $daysafter10 = dt_from_string->add_duration(DateTime::Duration->new(days => 10));
AddIssue( $patron, $barcode, $daysago20 );
AddReturn( $barcode, $branchcode );
$debarments = GetDebarments({borrowernumber => $patron->borrowernumber});
is(
    $debarments->[0]->{expiration},
    output_pref({ dt => $daysafter10, dateformat => 'iso', dateonly => 1 }),


    my $last_year = dt_from_string->clone->subtract( years => 1 );
    my $today = dt_from_string;
    my $new_debar_dt = C4::Circulation::_calculate_new_debar_dt( $patron, $item, $last_year, $today );
    is( $new_debar_dt->truncate( to => 'day' ),
        $today->clone->add( days => 365 / 15 * 7 )->truncate( to => 'day' ) );



    my $last_year = dt_from_string->clone->subtract( years => 1 );
    my $today = dt_from_string;
    my $new_debar_dt = C4::Circulation::_calculate_new_debar_dt( $patron, $item, $last_year, $today );
    is( $new_debar_dt->truncate( to => 'day' ),
        $today->clone->add( days => 333 )->truncate( to => 'day' ) );
};




        }
    );

    my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
    my $item = $builder->build_sample_item(
        {
            library => $library->branchcode,
            itype => $itemtype
        }
    );


    is( $dotransfer, 0, 'Do not transfer recalled item, it has already arrived' );
    is( $messages->{RecallPlacedAtHoldingBranch}, 1, "We found the recall");

    $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
    my $item2 = $builder->build_object({ class => 'Koha::Items', value => { itype => $itemtype } }); # this item will have a different holding branch to the pickup branch
    $recall = Koha::Recall->new(
        {   biblio_id         => $item2->biblionumber,
            item_id           => $item2->itemnumber,

        }
    );

    my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
    my $item = $builder->build_sample_item(
        {
            library => $library->branchcode,
            itype => $itemtype
        }
    );

    my $dt_to = dt_from_string();
    my $issue = AddIssue( $patron, $item->barcode, $dt_to );

    # We are making sure there is no regression, feel free to change the behavior if needed.
    # * WasReturned does not seem like a variable that should contain a borrowernumber

    is( $messages->{WasReturned}, $patron->borrowernumber, 'transferbook should have return a WasReturned flag is the item was issued before the transferbook call');

    # Reset issue
    $issue = AddIssue( $patron, $item->barcode, $dt_to );

    # We are making sure there is no regression, feel free to change the behavior if needed.
    # * Contrary to the POD, if ignore_reserves is not passed (or is false), any item reserve

Lines 58-64 subtest 'AddIssue() and AddReturn() real-time holds queue tests' => sub { Link Here

(-)a/t/db_dependent/Circulation_holdsqueue.t (-2 / +2 lines)
58	} );	58	} );
59		59
60	$action = 'AddIssue';	60	$action = 'AddIssue';
61	AddIssue( $patron->unblessed, $item->barcode, );	61	AddIssue( $patron, $item->barcode, );
62		62
63	$action = 'AddReturn';	63	$action = 'AddReturn';
64	AddReturn( $item->barcode );	64	AddReturn( $item->barcode );
Lines 66-72 subtest 'AddIssue() and AddReturn() real-time holds queue tests' => sub { Link Here
66	t::lib::Mocks::mock_preference( 'RealTimeHoldsQueue', 0 );	66	t::lib::Mocks::mock_preference( 'RealTimeHoldsQueue', 0 );
67		67
68	$action = 'AddIssue';	68	$action = 'AddIssue';
69	AddIssue( $patron->unblessed, $item->barcode, );	69	AddIssue( $patron, $item->barcode, );
70		70
71	$action = 'AddReturn';	71	$action = 'AddReturn';
72	AddReturn( $item->barcode );	72	AddReturn( $item->barcode );

Lines 118-124 my $orig_due = C4::Circulation::CalcDateDue( Link Here

(-)a/t/db_dependent/DecreaseLoanHighHolds.t (-1 / +1 lines)
118	dt_from_string(),	118	dt_from_string(),
119	$item->effective_itemtype,	119	$item->effective_itemtype,
120	$patron->branchcode,	120	$patron->branchcode,
121	$patron->unblessed	121	$patron
122	);	122	);
123		123
124	t::lib::Mocks::mock_preference( 'decreaseLoanHighHolds', 1 );	124	t::lib::Mocks::mock_preference( 'decreaseLoanHighHolds', 1 );




$is = IsAvailableForItemLevelRequest( $item1, $patron1 );
is( $is, 0, "Item cannot be held, 2 items available" );

my $issue1 = AddIssue( $patron2, $item1->barcode );

$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron1 } );
is( $is, 1, "Items availability: one item is available" );

$is = IsAvailableForItemLevelRequest( $item1, $patron1 );
is( $is, 0, "Item cannot be held, 1 item available" );

AddIssue( $patron2, $item2->barcode );

$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron1 } );
is( $is, 0, "Items availability: none of items are available" );

    $is = IsAvailableForItemLevelRequest( $item5, $patron1 );
    is( $is, 0, "Item5 cannot be requested to hold: 2 items, Item4 available, Item5 restricted" );

    AddIssue( $patron2, $item4->barcode );

    $is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblio2->biblionumber, patron => $patron1 } );
    is( $is, 0, "Items availability: 2 items, one allowed by smart rule and checked out, another one not allowed to be held by smart rule" );

Lines 82-90 foreach my $borrowernumber (@borrowernumbers) { Link Here

(-)a/t/db_dependent/Holds/RevertWaitingStatus.t (-3 / +2 lines)
82	}	82	}
83		83
84	ModReserveAffect( $itemnumber, $borrowernumbers[0] );	84	ModReserveAffect( $itemnumber, $borrowernumbers[0] );
85	my $patron = Koha::Patrons->find( $borrowernumbers[1] )->unblessed;	85	my $patron = Koha::Patrons->find( $borrowernumbers[1] );
86	C4::Circulation::AddIssue( $patron,	86	C4::Circulation::AddIssue( $patron, $item_barcode, undef, 'revert' );
87	$item_barcode, my $datedue, my $cancelreserve = 'revert' );
88		87
89	my $priorities = $dbh->selectall_arrayref(	88	my $priorities = $dbh->selectall_arrayref(
90	"SELECT priority FROM reserves ORDER BY priority ASC");	89	"SELECT priority FROM reserves ORDER BY priority ASC");





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

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

    my $item = $builder->build_sample_item(
        {

    );

    my $query = CGI->new;
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $item->biblionumber);

    my $reply = C4::ILSDI::Services::HoldTitle( $query );

    my $hold = $builder->build({
        source => 'Reserve',
        value => {
            borrowernumber => $patron->borrowernumber,
            biblionumber => $item->biblionumber,
            itemnumber => $item->itemnumber
        }

    my $biblio_with_no_item = $builder->build_sample_biblio;

    $query = CGI->new;
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $biblio_with_no_item->biblionumber);

    $reply = C4::ILSDI::Services::HoldTitle( $query );

    t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
    Koha::CirculationRules->set_rule(
        {
            categorycode => $patron->categorycode,
            itemtype     => $item2->{itype},
            branchcode   => $patron->branchcode,
            rule_name    => 'reservesallowed',
            rule_value   => 1,
        }
    );

    $query = CGI->new;
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $item2->biblionumber);
    $query->param( 'item_id', $item2->itemnumber);



    Koha::CirculationRules->set_rule(
        {
            categorycode => $patron->categorycode,
            itemtype     => $item2->{itype},
            branchcode   => $patron->branchcode,
            rule_name    => 'reservesallowed',
            rule_value   => 0,
        }
    );

    $query = CGI->new;
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $item2->biblionumber);
    $query->param( 'item_id', $item2->itemnumber);



    Koha::CirculationRules->set_rule(
        {
            categorycode => $patron->categorycode,
            itemtype     => $item3->{itype},
            branchcode   => $patron->branchcode,
            rule_name    => 'reservesallowed',
            rule_value   => 10,
        }
    );

    $query = CGI->new;
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $item4->biblionumber);
    $query->param( 'item_id', $item4->itemnumber);


    is( $reply->{code}, 'damaged', "Item is damaged" );

    my $module = Test::MockModule->new('C4::Context');
    $module->mock('userenv', sub { { patron => $patron->unblessed } });
    my $issue = C4::Circulation::AddIssue($patron, $item3->barcode);
    t::lib::Mocks::mock_preference( 'AllowHoldsOnPatronsPossessions', '0' );

    $query = CGI->new;
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $item3->biblionumber);
    $query->param( 'item_id', $item3->itemnumber);
    $query->param( 'pickup_location', $origin_branch->{branchcode});

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

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

    my $origin_branch = $builder->build(


    my $query = CGI->new;
    $query->param( 'pickup_location', $pickup_branch->{branchcode} );
    $query->param( 'patron_id', $patron->borrowernumber);
    $query->param( 'bib_id', $item->biblionumber);
    $query->param( 'item_id', $item->itemnumber);



    $reply = C4::ILSDI::Services::HoldItem( $query );
    is( $reply->{code}, undef, "Item hold, Item can be transferred" );
    my $hold = Koha::Holds->search({ itemnumber => $item->itemnumber, borrowernumber => $patron->borrowernumber })->next;
    is( $hold->branchcode, $pickup_branch->{branchcode}, 'The library id is correctly set' );

    Koha::Holds->search()->delete();

    $reply = C4::ILSDI::Services::HoldTitle( $query );
    is( $reply->{code}, undef, "Record hold, Item con be transferred" );
    $hold = Koha::Holds->search({ biblionumber => $item->biblionumber, borrowernumber => $patron->borrowernumber })->next;
    is( $hold->branchcode, $pickup_branch->{branchcode}, 'The library id is correctly set' );

    $schema->storage->txn_rollback;

    $cgi->param( item_id   => $item->itemnumber );

    t::lib::Mocks::mock_userenv( { patron => $patron } );    # For AddIssue
    my $checkout = C4::Circulation::AddIssue( $patron, $item->barcode );

    # Everything is ok
    my $reply = C4::ILSDI::Services::RenewLoan($cgi);

    my $module = Test::MockModule->new('C4::Context');
    $module->mock('userenv', sub { { branch => $library->branchcode } });
    my $date_due = Koha::DateUtils::dt_from_string()->add(weeks => 2);
    my $issue1 = C4::Circulation::AddIssue($patron, $item1->barcode, $date_due);
    my $date_due1 = Koha::DateUtils::dt_from_string( $issue1->date_due );
    my $issue2 = C4::Circulation::AddIssue($patron, $item2->barcode, $date_due);
    my $date_due2 = Koha::DateUtils::dt_from_string( $issue2->date_due );
    my $issue3 = C4::Circulation::AddIssue($patron, $item3->barcode, $date_due);
    my $date_due3 = Koha::DateUtils::dt_from_string( $issue3->date_due );

    my $cgi = CGI->new;

Lines 1602-1608 subtest 'Checking in hook' => sub { Link Here

(-)a/t/db_dependent/Illrequests.t (-1 / +1 lines)
1602	t::lib::Mocks::mock_preference('CirculateILL', 1);	1602	t::lib::Mocks::mock_preference('CirculateILL', 1);
1603		1603
1604	# Add an issue	1604	# Add an issue
1605	AddIssue( $patron->unblessed, $item->barcode );	1605	AddIssue( $patron, $item->barcode );
1606	# Make the item withdrawn so checking-in is rejected	1606	# Make the item withdrawn so checking-in is rejected
1607	t::lib::Mocks::mock_preference('BlockReturnOfWithdrawnItems', 1);	1607	t::lib::Mocks::mock_preference('BlockReturnOfWithdrawnItems', 1);
1608	$item->set({ withdrawn => 1 })->store;	1608	$item->set({ withdrawn => 1 })->store;




            class => 'Koha::Checkouts',
            value => {
                itemnumber      => $item->itemnumber,
                borrowernumber  => $patron->borrowernumber,
                onsite_checkout => 0,
                renewals_count  => 99,
                auto_renew      => 0
            }
        }
    );

    my $line = Koha::Account::Line->new(
    {
        borrowernumber    => $patron->borrowernumber,

    my $account = $patron->account;

    t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
    my $checkout = AddIssue( $patron, $item->barcode );

    my $line = $account->add_debit({
        amount    => 10,

    my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };
    my $branchcode   = $builder->build({ source => 'Branch' })->{ branchcode };

    my $staff = $builder->build_object({ class => 'Koha::Patrons' });
    t::lib::Mocks::mock_userenv({ patron => $staff });

    my $borrower = $builder->build_object(
        {
            class => 'Koha::Patrons',
            value => {
                cardnumber => 'dariahall',
                surname => 'Hall',
                firstname => 'Daria',
                categorycode => $categorycode,
                branchcode => $branchcode,
            }
        }
    );

    my $account = Koha::Account->new({ patron_id => $borrower->id });






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

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

    my $item_1 = $builder->build_sample_item;
    my $item_2 = $builder->build_sample_item({ biblionumber => $item_1->biblionumber });

    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, $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" );

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

    $recall2->set_cancelled;
    C4::Circulation::AddIssue( $patron2, $item2->barcode );
    C4::Circulation::AddIssue( $patron2, $item1->barcode );
    is( $biblio->can_be_recalled({ patron => $patron1 }), 2, "Can recall two items" );

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




                }
            );

            C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(3)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(3)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            )->store;

            my $issue =
              C4::Circulation::AddIssue( $patron, $barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            )->store;

            my $issue =
              C4::Circulation::AddIssue( $patron, $barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $item->barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;

            );

            my $issue =
              C4::Circulation::AddIssue( $patron, $barcode );

            # Simulate item marked as lost
            $item->itemlost(1)->store;




    my $patron = Koha::Patron->new($patron_data)->store;
    my ($biblionumber) = AddBiblio( MARC::Record->new, '' );
    my $biblio = Koha::Biblios->find( $biblionumber );
    my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
    my $item = $builder->build_object(
        {
            class => 'Koha::Items',

                biblionumber  => $biblio->biblionumber,
                itemlost      => 0,
                withdrawn     => 0,
                itype         => $itemtype,
            }
        }
    );

    my $issue = AddIssue( $patron, $item->barcode, DateTime->now->subtract( days => 1 ) );
    my $overdues = Koha::Patrons->find( $patron->id )->overdues; # Koha::Patron->overdues prefetches
    my $overdue = $overdues->next->unblessed_all_relateds;
    is( $overdue->{issue_id}, $issue->issue_id, 'unblessed_all_relateds has field from the original table (issues)' );




    is( $old_checkouts->count, 0, 'old_checkouts should not return any issues for that patron' );
    is( ref($old_checkouts), 'Koha::Old::Checkouts', 'old_checkouts should return a Koha::Old::Checkouts object' );

    # Not sure how this is useful, but AddIssue pass this variable to different other subroutines
    $patron = Koha::Patrons->find( $patron->borrowernumber )->unblessed;

    t::lib::Mocks::mock_userenv({ branchcode => $library->{branchcode} });

    AddIssue( $patron, $item_1->barcode, DateTime->now->subtract( days => 1 ) );
    AddIssue( $patron, $item_2->barcode, DateTime->now->subtract( days => 5 ) );
    AddIssue( $patron, $item_3->barcode );

    $patron = Koha::Patrons->find( $patron->{borrowernumber} );
    $checkouts = $patron->checkouts;
    is( $checkouts->count, 3, 'checkouts should return 3 issues for that patron' );
    is( ref($checkouts), 'Koha::Checkouts', 'checkouts should return a Koha::Checkouts object' );


    t::lib::Mocks::mock_preference({ branchcode => $library->{branchcode} });

    $patron = Koha::Patrons->find( $patron->{borrowernumber} );

    AddIssue( $patron, $item_1->barcode, DateTime->now->subtract( days => 1 ) );
    AddIssue( $patron, $item_2->barcode, DateTime->now->subtract( days => 5 ) );
    AddIssue( $patron, $item_3->barcode );

    $patron = Koha::Patrons->find( $patron->{borrowernumber} );
    my $overdues = $patron->overdues;
    is( $overdues->count, 2, 'Patron should have 2 overdues');
    is( $overdues->next->itemnumber, $item_1->itemnumber, 'The issue should be returned in the same order as they have been done, first is correct' );

Lines 75-85 subtest 'after_circ_action() hook tests' => sub { Link Here

(-)a/t/db_dependent/Koha/Plugins/Circulation_hooks.t (-2 / +2 lines)
75	subtest 'AddIssue' => sub {	75	subtest 'AddIssue' => sub {
76	plan tests => 2;	76	plan tests => 2;
77		77
78	warning_like { AddIssue( $patron->unblessed, $item_1->barcode ); }	78	warning_like { AddIssue( $patron, $item_1->barcode ); }
79	qr/after_circ_action called with action: checkout, ref: Koha::Checkout type: issue/,	79	qr/after_circ_action called with action: checkout, ref: Koha::Checkout type: issue/,
80	'AddIssue calls the after_circ_action hook';	80	'AddIssue calls the after_circ_action hook';
81		81
82	warning_like { AddIssue( $patron->unblessed, $item_2->barcode, undef, undef, undef, undef, { onsite_checkout => 1 } ); }	82	warning_like { AddIssue( $patron, $item_2->barcode, undef, undef, undef, undef, { onsite_checkout => 1 } ); }
83	qr/after_circ_action called with action: checkout, ref: Koha::Checkout type: onsite_checkout/,	83	qr/after_circ_action called with action: checkout, ref: Koha::Checkout type: onsite_checkout/,
84	'AddIssue calls the after_circ_action hook (onsite_checkout case)';	84	'AddIssue calls the after_circ_action hook (onsite_checkout case)';
85	};	85	};

Lines 74-80 my $item = $builder->build_sample_item( Link Here

(-)a/t/db_dependent/Koha/Template/Plugin/CirculationRules.t (-1 / +1 lines)
74	}	74	}
75	);	75	);
76		76
77	my $issue = AddIssue( $patron->unblessed, $item->barcode );	77	my $issue = AddIssue( $patron, $item->barcode );
78		78
79	my $rules = $plugin->Renewals( $patron->id, $item->id );	79	my $rules = $plugin->Renewals( $patron->id, $item->id );
80		80




$mocked_datetime->mock( 'now', sub { return $now_value->clone; } );

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

my $patron2 = $builder->build( { source => 'Borrower' } );

my $item = $builder->build_sample_item();

    {
        class => 'Koha::Holds',
        value => {
            borrowernumber => $patron->borrowernumber,
            biblionumber   => $item->biblionumber
        }
    }

        module      => 'test',
        letter_code => 'TEST_PATRON',
        tables      => {
            borrowers => $patron->borrowernumber,
        },
    )
);
is( $prepared_letter->{content}, $patron->borrowernumber, 'Patron object used correctly with scalar for content' );
is( $prepared_letter->{title}, $patron->firstname, 'Patron object used correctly with scalar for title' );

$prepared_letter = GetPreparedLetter(
    (
        module      => 'test',
        letter_code => 'TEST_PATRON',
        tables      => {
            borrowers => $patron->unblessed,
        },
    )
);
is( $prepared_letter->{content}, $patron->borrowernumber, 'Patron object used correctly with hashref for content' );
is( $prepared_letter->{title}, $patron->firstname, 'Patron object used correctly with hashref for title' );

$prepared_letter = GetPreparedLetter(
    (
        module      => 'test',
        letter_code => 'TEST_PATRON',
        tables      => {
            borrowers => [ $patron->borrowernumber ],
        },
    )
);
is( $prepared_letter->{content}, $patron->borrowernumber, 'Patron object used correctly with arrayref for content' );
is( $prepared_letter->{title}, $patron->firstname, 'Patron object used correctly with arrayref for title' );

$prepared_letter = GetPreparedLetter(
    (
        module      => 'test',
        letter_code => 'TEST_PATRON',
        objects      => {
            borrower => scalar Koha::Patrons->find( $patron->borrowernumber ),
        },
    )
);
is( $prepared_letter->{content}, $patron->borrowernumber, 'Patron object used correctly as object' );

$sth->execute( "TEST_BIBLIO", "[% biblio.title %]", "[% biblio.id %]" );
$prepared_letter = GetPreparedLetter(

        module      => 'test',
        letter_code => 'TEST_HOLD',
        tables      => {
            reserves => { borrowernumber => $patron->borrowernumber, biblionumber => $item->biblionumber },
        },
    )
);

            module      => 'test',
            letter_code => 'TEST_HOLD',
            tables      => {
                reserves => [ $patron->borrowernumber, $item->biblionumber ],
            },
        )
    )

        letter_code => 'TEST_HOLD',
        tables      => {
            'branches'    => $library,
            'borrowers'   => $patron->unblessed,
            'biblio'      => $item->biblionumber,
            'biblioitems' => $item->biblioitemnumber,
            'reserves'    => $hold->unblessed,

    plan tests => 8;

    my $library = $builder->build( { source => 'Branch' } );
    my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;

    my $item1 = $builder->build_sample_item(
        {
            barcode        => 'a_t_barcode',
            library        => $library->{branchcode},
            itype          => $itemtype,
            itemcallnumber => 'itemcallnumber1',
        }
    );

        {
            barcode        => 'another_t_barcode',
            library        => $library->{branchcode},
            itype          => $itemtype,
            itemcallnumber => 'itemcallnumber2',
        }
    );

        {
            barcode        => 'another_t_barcode_3',
            library        => $library->{branchcode},
            itype          => $itemtype,
            itemcallnumber => 'itemcallnumber3',
        }
    );

The order <<aqorders.ordernumber>> (<<biblio.title>>) has been received.
Your library.
        |;
        my $params = { code => $code, branchcode => $branchcode, tables => { branches => $library, borrowers => $patron->unblessed, biblio => $biblio1, aqorders => $order } };
        my $letter = process_letter( { template => $template, %$params });
        my $tt_template = q|
Dear [% borrower.firstname %] [% borrower.surname %],

        my $checkout_code = 'CHECKOUT';
        my $checkin_code = 'CHECKIN';

#        my $message_attr_1 = $builder->build_object(
#            {
#                class => 'Koha::MessageAttribute',
#                value => { message_name => "Item_Checkout", takes_days => 0 }
#            }
#        )->store;
#
#        my $message_attr_2 = $builder->build_object(
#            {
#                class => 'Koha::MessageAttribute',
#                value => { message_name => "Item_Check_in", takes_days => 0 }
#            }
#        )->store;

        my $dbh = C4::Context->dbh;
        # Enable notification for CHECKOUT - Things are hardcoded here but should work with default data
        $dbh->do(q|INSERT INTO borrower_message_preferences( borrowernumber, message_attribute_id ) VALUES ( ?, ? )|,
            undef, $patron->borrowernumber, 6 );
        my $borrower_message_preference_id = $dbh->last_insert_id(undef, undef, "borrower_message_preferences", undef);
        $dbh->do(q|INSERT INTO borrower_message_transport_preferences( borrower_message_preference_id, message_transport_type) VALUES ( ?, ? )|, undef, $borrower_message_preference_id, 'email' );

        # Enable notification for CHECKIN - Things are hardcoded here but should work with default data
        $dbh->do(q|INSERT INTO borrower_message_preferences( borrowernumber, message_attribute_id ) VALUES ( ?, ? )|,
            undef, $patron->borrowernumber, 5);
        $borrower_message_preference_id = $dbh->last_insert_id(undef, undef, "borrower_message_preferences", undef);
        $dbh->do(q|INSERT INTO borrower_message_transport_preferences( borrower_message_preference_id, message_transport_type) VALUES ( ?, ? )|, undef, $borrower_message_preference_id, 'email' );


        # historic syntax
        my $checkout_template = q|
The following items have been checked out:


        C4::Circulation::AddIssue( $patron, $item1->{barcode} );
        my $first_checkout_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;

        C4::Circulation::AddIssue( $patron, $item2->{barcode} );
        my $second_checkout_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;

        AddReturn( $item1->{barcode} );
        my $first_checkin_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;

        AddReturn( $item2->{barcode} );
        my $second_checkin_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;



        C4::Circulation::AddIssue( $patron, $item1->{barcode} );
        my $first_checkout_tt_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;

        C4::Circulation::AddIssue( $patron, $item2->{barcode} );
        my $second_checkout_tt_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;

        AddReturn( $item1->{barcode} );
        my $first_checkin_tt_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;

        AddReturn( $item2->{barcode} );
        my $second_checkin_tt_letter = Koha::Notice::Messages->search( {}, { order_by => { -desc => 'message_id' } } )->next;



        my $dbh = C4::Context->dbh;
        # Enable notification for DUEDGST - Things are hardcoded here but should work with default data
        $dbh->do(q|INSERT INTO borrower_message_preferences( borrowernumber, message_attribute_id ) VALUES ( ?, ? )|, undef, $patron->borrowernumber, 1 );
        my $borrower_message_preference_id = $dbh->last_insert_id(undef, undef, "borrower_message_preferences", undef);
        $dbh->do(q|INSERT INTO borrower_message_transport_preferences( borrower_message_preference_id, message_transport_type) VALUES ( ?, ? )|, undef, $borrower_message_preference_id, 'email' );


        my $reserve_id1 = C4::Reserves::AddReserve(
            {
                branchcode     => $library->{branchcode},
                borrowernumber => $patron->borrowernumber,
                biblionumber   => $biblio1->{biblionumber},
                notes          => "a note",
                itemnumber     => $item1->{itemnumber},

        my $reserve_id2 = C4::Reserves::AddReserve(
            {
                branchcode     => $library->{branchcode},
                borrowernumber => $patron->borrowernumber,
                biblionumber   => $biblio1->{biblionumber},
                notes          => "a note",
                itemnumber     => $item1->{itemnumber},

        my $reserve_id3 = C4::Reserves::AddReserve(
            {
                branchcode     => $library->{branchcode},
                borrowernumber => $patron->borrowernumber,
                biblionumber   => $biblio2->{biblionumber},
                notes          => "another note",
                itemnumber     => $item2->{itemnumber},


        my $checkout = C4::Circulation::AddIssue( $patron, $item1->{barcode} ); # Add a first checkout
        $checkout->set( { timestamp => $now, issuedate => $one_minute_ago } )->store;
        my $first_slip = C4::Members::IssueSlip( $branchcode, $patron->borrowernumber );

        $checkout = C4::Circulation::AddIssue( $patron, $item2->{barcode} ); # Add a second checkout
        $checkout->set( { timestamp => $now, issuedate => $now } )->store;
        my $yesterday = dt_from_string->subtract( days => 1 );
        C4::Circulation::AddIssue( $patron, $item3->{barcode}, $yesterday ); # Add an overdue
        my $second_slip = C4::Members::IssueSlip( $branchcode, $patron->borrowernumber );

        # Cleanup
        AddReturn( $item1->{barcode} );


        $checkout = C4::Circulation::AddIssue( $patron, $item1->{barcode} ); # Add a first checkout
        $checkout->set( { timestamp => $now, issuedate => $one_minute_ago } )->store;
        my $first_tt_slip = C4::Members::IssueSlip( $branchcode, $patron->borrowernumber );

        $checkout = C4::Circulation::AddIssue( $patron, $item2->{barcode} ); # Add a second checkout
        $checkout->set( { timestamp => $now, issuedate => $now } )->store;
        C4::Circulation::AddIssue( $patron, $item3->{barcode}, $yesterday ); # Add an overdue
        my $second_tt_slip = C4::Members::IssueSlip( $branchcode, $patron->borrowernumber );

        # There is too many line breaks generated by the historic syntax
        $second_slip->{content} =~ s|</p>\n\n\n<p>|</p>\n\n<p>|s;

        my $letter = C4::Overdues::parse_overdues_letter(
            {
                letter_code => $code,
                borrowernumber => $patron->borrowernumber,
                branchcode  => $library->{branchcode},
                items       => \@items,
                substitute  => {

        my $tt_letter = C4::Overdues::parse_overdues_letter(
            {
                letter_code => $code,
                borrowernumber => $patron->borrowernumber,
                branchcode  => $library->{branchcode},
                items       => \@items,
                substitute  => {

        $dbh->do("DELETE FROM message_queue");

        # Enable notification for CHECKOUT - Things are hardcoded here but should work with default data
        $dbh->do(q|INSERT INTO borrower_message_preferences( borrowernumber, message_attribute_id ) VALUES ( ?, ? )|, undef, $patron->borrowernumber, 6 );
        my $borrower_message_preference_id = $dbh->last_insert_id(undef, undef, "borrower_message_preferences", undef);
        $dbh->do(q|INSERT INTO borrower_message_transport_preferences( borrower_message_preference_id, message_transport_type) VALUES ( ?, ? )|, undef, $borrower_message_preference_id, 'email' );
        # Enable notification for CHECKIN - Things are hardcoded here but should work with default data
        $dbh->do(q|INSERT INTO borrower_message_preferences( borrowernumber, message_attribute_id ) VALUES ( ?, ? )|, undef, $patron->borrowernumber, 5 );
        $borrower_message_preference_id = $dbh->last_insert_id(undef, undef, "borrower_message_preferences", undef);
        $dbh->do(q|INSERT INTO borrower_message_transport_preferences( borrower_message_preference_id, message_transport_type) VALUES ( ?, ? )|, undef, $borrower_message_preference_id, 'email' );


Lines 66-73 my $borrowernumber1 = Link Here

(-)a/t/db_dependent/Members/GetAllIssues.t (-2 / +2 lines)
66	Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;	66	Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;
67	my $borrowernumber2 =	67	my $borrowernumber2 =
68	Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;	68	Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;
69	my $borrower1 = Koha::Patrons->find( $borrowernumber1 )->unblessed;	69	my $borrower1 = Koha::Patrons->find( $borrowernumber1 );
70	my $borrower2 = Koha::Patrons->find( $borrowernumber2 )->unblessed;	70	my $borrower2 = Koha::Patrons->find( $borrowernumber2 );
71		71
72	my $module = Test::MockModule->new('C4::Context');	72	my $module = Test::MockModule->new('C4::Context');
73	$module->mock( 'userenv', sub { { branch => $branchcode } } );	73	$module->mock( 'userenv', sub { { branch => $branchcode } } );





my $borrowernumber =
  Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;
my $borrower = Koha::Patrons->find( $borrowernumber );

my $module = Test::MockModule->new('C4::Context');
$module->mock( 'userenv', sub { { branch => $branchcode } } );


        # Set timestamps to the same value to avoid a different order
        Koha::Checkouts->search(
            { borrowernumber => $borrower->borrowernumber }
        )->update( { timestamp => dt_from_string } );

        $expected_slip = <<EOS;


        # Set timestamps to the same value to avoid a different order
        Koha::Checkouts->search(
            { borrowernumber => $borrower->borrowernumber }
        )->update( { timestamp => dt_from_string } );

        $expected_slip = <<EOS;




my $itemtype        = $builder->build({ source => 'Itemtype' })->{itemtype};

C4::Context->_new_userenv('xxx');
my $patron = $builder->build_object({
    class => 'Koha::Patrons',
    value => {
        branchcode => $library->{branchcode},
        flags      => 1, # superlibrarian
    }
});
t::lib::Mocks::mock_userenv({ patron => $patron });
t::lib::Mocks::mock_userenv({ patron => $p });

my $patron2 = $builder->build_object({
    class => 'Koha::Patrons',
    value => {
        branchcode => $library->{branchcode},
    }
});
my $patron3 = $builder->build_object({
    class => 'Koha::Patrons',
    value => {
        branchcode => $another_library->{branchcode},
        flags => undef,
    }
});
my $p3 = Koha::Patrons->find( $patron3->{borrowernumber} );

# Discharge not possible with issues
my ( $biblionumber ) = AddBiblio( MARC::Record->new, '');

);

AddIssue( $patron, $barcode );
is( Koha::Patron::Discharge::can_be_discharged({ borrowernumber => $patron->borrowernumber }), 0, 'A patron with issues cannot be discharged' );

is( Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber }), undef, 'No request done if patron has issues' );
is( Koha::Patron::Discharge::discharge({ borrowernumber => $patron->borrowernumber }), undef, 'No discharge done if patron has issues' );
is_deeply( [ Koha::Patron::Discharge::get_pendings ], [], 'There is no pending discharge request' );
is_deeply( [ Koha::Patron::Discharge::get_validated ], [], 'There is no validated discharge' );

AddReturn( $barcode );

# Discharge possible without issue
is( Koha::Patron::Discharge::can_be_discharged({ borrowernumber => $patron->borrowernumber }), 1, 'A patron without issues can be discharged' );

is(Koha::Patron::Discharge::generate_as_pdf,undef,"Confirm failure when lacking borrower number");

# Verify that the user is not discharged anymore if the restriction has been lifted
Koha::Patron::Discharge::discharge( { borrowernumber => $patron->borrowernumber } );
Koha::Patron::Discharge::discharge( { borrowernumber => $patron2->borrowernumber } );
Koha::Patron::Discharge::discharge( { borrowernumber => $patron3->borrowernumber } );
is( Koha::Patron::Discharge::is_discharged( { borrowernumber => $patron->borrowernumber } ), 1, 'The patron has been discharged' );
is( Koha::Patrons->find( $patron->borrowernumber )->is_debarred, '9999-12-31', 'The patron has been debarred after discharge' );
is( scalar( Koha::Patron::Discharge::get_validated ),             3,            'There are 3 validated discharges' );
is( scalar( Koha::Patron::Discharge::get_validated( { borrowernumber => $patron->borrowernumber } ) ), 1, 'There is 1 validated discharge for a given patron' );
is( scalar( Koha::Patron::Discharge::get_validated( { branchcode => $library->{branchcode} } ) ), 2, 'There is 2 validated discharges for a given branchcode' );    # This is not used in the code yet
Koha::Patron::Debarments::DelUniqueDebarment( { 'borrowernumber' => $patron->borrowernumber, 'type' => 'DISCHARGE' } );
ok( !Koha::Patrons->find( $patron->borrowernumber )->is_debarred, 'The debarment has been lifted' );
ok( !Koha::Patron::Discharge::is_discharged( { borrowernumber => $patron->borrowernumber } ), 'The patron is not discharged after the restriction has been lifted' );

# Verify that the discharge works multiple times
Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber });
is(scalar( Koha::Patron::Discharge::get_pendings ), 1, 'There is a pending discharge request (second time)');
Koha::Patron::Discharge::discharge( { borrowernumber => $patron->borrowernumber } );
is_deeply( [ Koha::Patron::Discharge::get_pendings ], [], 'There is no pending discharge request (second time)');

# Check if PDF::FromHTML is installed.


# Tests for if PDF::FromHTML is installed
if ($check) {
    isnt( Koha::Patron::Discharge::generate_as_pdf({ borrowernumber => $patron->borrowernumber }), undef, "Temporary PDF generated." );
}
# Tests for if PDF::FromHTML is not installed
else {
    warning_like { Koha::Patron::Discharge::generate_as_pdf({ borrowernumber => $patron->borrowernumber, testing => 1 }) }
          [ qr/Can't locate PDF\/FromHTML.pm in \@INC/ ],
          "Expected failure because of missing PDF::FromHTML.";
}

# FIXME Should be a Koha::Object object
is( ref(Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber })), 'Koha::Schema::Result::Discharge', 'Discharge request sent' );

subtest 'search_limited' => sub {
    plan tests => 4;

    my $group_2 = Koha::Library::Group->new( { title => 'TEST Group 2' } )->store;
    # $patron and $patron2 are from the same library, $patron3 from another one
    # Logged in user is $patron, superlibrarian
    t::lib::Mocks::mock_userenv({ patron => $patron });
    Koha::Library::Group->new({ parent_id => $group_1->id,  branchcode => $patron->branchcode })->store();
    Koha::Library::Group->new({ parent_id => $group_2->id,  branchcode => $patron3->branchcode })->store();
    Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber });
    Koha::Patron::Discharge::request({ borrowernumber => $patron2->borrowernumber });
    Koha::Patron::Discharge::request({ borrowernumber => $patron3->borrowernumber });
    is( scalar( Koha::Patron::Discharge::get_pendings), 3, 'With permission, all discharges are visible' );
    is( Koha::Patron::Discharge::count({pending => 1}), 3, 'With permission, all discharges are visible' );

    # With patron 3 logged in, only discharges from their group are visible
    t::lib::Mocks::mock_userenv({ patron => $patron3 });
    is( scalar( Koha::Patron::Discharge::get_pendings), 1, 'Without permission, only discharge from our group are visible' );
    is( Koha::Patron::Discharge::count({pending => 1}), 1, 'Without permission, only discharge from our group are visible' );
};




test_it($cpvmappings, "PreIssue");

# Issue item_1 to $patron:
my $patron_get_mem = Koha::Patrons->find( $patron->{borrowernumber} );
BAIL_OUT("Issue failed")
    unless AddIssue($patron_get_mem, $item_1->{barcode});


my $prev_item = $builder->build_sample_item->unblessed;
# Second is Checked Out
BAIL_OUT("CanBookBeIssued Issue failed")
    unless AddIssue($patron, $prev_item->{barcode});

# Mappings
my $CBBI_mappings = [

    my $item1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
    my $item2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });

    AddIssue($patron, $item1->barcode);

    is($patron->do_check_for_previous_checkout($item1->unblessed), 1, 'Check only one item if bibliographic record is serial');
    is($patron->do_check_for_previous_checkout($item2->unblessed), 0, 'Check only one item if bibliographic record is serial');




    t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode, flags => 1 });

    my $item = $builder->build_sample_item({
        library => $library->branchcode,
    });

    Koha::CirculationRules->set_rules(

        }
    );

    AddIssue( $patron, $item->barcode, undef, 0 );
    my $checkout = $item->checkout;
    ok( defined($checkout), "Checkout added");
    is( $checkout->renewals_count, 0, "Correct renewals");

    my $ils = C4::SIP::ILS->new({ id => $library->branchcode });
    my $sip_patron = C4::SIP::ILS::Patron->new( $patron->cardnumber );
    my $transaction = $ils->checkout($patron->cardnumber, $item->barcode);

    is( $transaction->{screen_msg},"Item already checked out to you: renewing item.", "We get a success message when issue is renewed");

    $checkout->discard_changes();
    is( $checkout->renewals_count, 1, "Renewals has been reduced");




}

sub try_issue {
    my ($cardnumber, $item_barcode ) = @_;
    my $issuedate = '2011-05-16';
    my $patron = Koha::Patrons->find( { cardnumber => $cardnumber } );
    my ($issuingimpossible,$needsconfirmation) = CanBookBeIssued( $patron, $item_barcode );
    my $issue = AddIssue($patron, $item_barcode, undef, 0, $issuedate);
    return dt_from_string( $issue->date_due );
}

sub try_return {
    my $item_barcode = shift;
    my ($ret, $messages, $iteminformation, $borrower) = AddReturn($item_barcode);
    return $ret;
}

Lines 176-182 subtest 'Display circulation table correctly' => sub { Link Here

(-)a/t/db_dependent/selenium/regressions.t (-2 / +1 lines)
176	}	176	}
177	);	177	);
178		178
179	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	179	C4::Circulation::AddIssue( $patron, $item->barcode );
180		180
181	my $mainpage = $s->base_url . q\|mainpage.pl\|;	181	my $mainpage = $s->base_url . q\|mainpage.pl\|;
182	$driver->get($mainpage . q\|?logout.x=1\|);	182	$driver->get($mainpage . q\|?logout.x=1\|);
183	-

Return to bug 32496

Lines 246-252 sub kocIssueItem { Link Here

(-)a/offline_circ/process_koc.pl (-19 / +18 lines)
246		246
247	my $branchcode = C4::Context->userenv->{branch};	247	my $branchcode = C4::Context->userenv->{branch};
248	my $patron = Koha::Patrons->find( { cardnumber => $circ->{cardnumber} } );	248	my $patron = Koha::Patrons->find( { cardnumber => $circ->{cardnumber} } );
249	my $borrower = $patron->unblessed;
250	my $item = Koha::Items->find({ barcode => $circ->{barcode} });	249	my $item = Koha::Items->find({ barcode => $circ->{barcode} });
251	my $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );	250	my $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
252	my $biblio = $item->biblio;	251	my $biblio = $item->biblio;
Lines 254-260 sub kocIssueItem { Link Here
254	if ( $issue ) { ## Item is currently checked out to another person.	253	if ( $issue ) { ## Item is currently checked out to another person.
255	#warn "Item Currently Issued.";	254	#warn "Item Currently Issued.";
256		255
257	if ( $issue->borrowernumber eq $borrower->{'borrowernumber'} ) { ## Issued to this person already, renew it.	256	if ( $issue->borrowernumber eq $patron->borrowernumber ) { ## Issued to this person already, renew it.
258	#warn "Item issued to this member already, renewing.";	257	#warn "Item issued to this member already, renewing.";
259		258
260	C4::Circulation::AddRenewal(	259	C4::Circulation::AddRenewal(
Lines 270-280 sub kocIssueItem { Link Here
270	title => $biblio->title,	269	title => $biblio->title,
271	biblionumber => $biblio->biblionumber,	270	biblionumber => $biblio->biblionumber,
272	barcode => $item->barcode,	271	barcode => $item->barcode,
273	firstname => $borrower->{ 'firstname' },	272	firstname => $patron->firstname,
274	surname => $borrower->{ 'surname' },	273	surname => $patron->surname,
275	borrowernumber => $borrower->{'borrowernumber'},	274	borrowernumber => $patron->borrowernumber,
276	cardnumber => $borrower->{'cardnumber'},	275	cardnumber => $patron->cardnumber,
277	datetime => $circ->{ 'datetime' }	276	datetime => $circ->datetime
278	};	277	};
279		278
280	} else {	279	} else {
Lines 285-301 sub kocIssueItem { Link Here
285	my ( $c_y, $c_m, $c_d ) = split( /-/, $circ->{'date'} );	284	my ( $c_y, $c_m, $c_d ) = split( /-/, $circ->{'date'} );
286		285
287	if ( Date_to_Days( $i_y, $i_m, $i_d ) < Date_to_Days( $c_y, $c_m, $c_d ) ) { ## Current issue to a different persion is older than this issue, return and issue.	286	if ( Date_to_Days( $i_y, $i_m, $i_d ) < Date_to_Days( $c_y, $c_m, $c_d ) ) { ## Current issue to a different persion is older than this issue, return and issue.
288	C4::Circulation::AddIssue( $borrower, $circ->{'barcode'}, undef, undef, $circ->{'date'} ) unless ( DEBUG );	287	C4::Circulation::AddIssue( $patron, $circ->{'barcode'}, undef, undef, $circ->{'date'} ) unless ( DEBUG );
289	push @output, {	288	push @output, {
290	issue => 1,	289	issue => 1,
291	title => $biblio->title,	290	title => $biblio->title,
292	biblionumber => $biblio->biblionumber,	291	biblionumber => $biblio->biblionumber,
293	barcode => $item->barcode,	292	barcode => $item->barcode,
294	firstname => $borrower->{ 'firstname' },	293	firstname => $patron->firstname,
295	surname => $borrower->{ 'surname' },	294	surname => $patron->surname,
296	borrowernumber => $borrower->{'borrowernumber'},	295	borrowernumber => $patron->borrowernumber,
297	cardnumber => $borrower->{'cardnumber'},	296	cardnumber => $patron->cardnumber,
298	datetime => $circ->{ 'datetime' }	297	datetime => $circ->datetime
299	};	298	};
300		299
301	} else { ## Current issue is newer than this issue, write a 'returned' issue, as the item is most likely in the hands of someone else now.	300	} else { ## Current issue is newer than this issue, write a 'returned' issue, as the item is most likely in the hands of someone else now.
Lines 305-321 sub kocIssueItem { Link Here
305	}	304	}
306	}	305	}
307	} else { ## Item is not checked out to anyone at the moment, go ahead and issue it	306	} else { ## Item is not checked out to anyone at the moment, go ahead and issue it
308	C4::Circulation::AddIssue( $borrower, $circ->{'barcode'}, undef, undef, $circ->{'date'} ) unless ( DEBUG );	307	C4::Circulation::AddIssue( $patron, $circ->{'barcode'}, undef, undef, $circ->{'date'} ) unless ( DEBUG );
309	push @output, {	308	push @output, {
310	issue => 1,	309	issue => 1,
311	title => $biblio->title,	310	title => $biblio->title,
312	biblionumber => $biblio->biblionumber,	311	biblionumber => $biblio->biblionumber,
313	barcode => $item->barcode,	312	barcode => $item->barcode,
314	firstname => $borrower->{ 'firstname' },	313	firstname => $patron->firstname,
315	surname => $borrower->{ 'surname' },	314	surname => $patron->surname,
316	borrowernumber => $borrower->{'borrowernumber'},	315	borrowernumber => $patron->borrowernumber,
317	cardnumber => $borrower->{'cardnumber'},	316	cardnumber => $patron->cardnumber,
318	datetime =>$circ->{ 'datetime' }	317	datetime =>$circ->datetime
319	};	318	};
320	}	319	}
321	}	320	}

Lines 160-166 my $borrower_id1 = Koha::Patron->new({ Link Here

(-)a/t/db_dependent/Circulation/issue.t (-13 / +11 lines)
160	branchcode => $branchcode_1	160	branchcode => $branchcode_1
161	})->store->borrowernumber;	161	})->store->borrowernumber;
162	my $patron_1 = Koha::Patrons->find( $borrower_id1 );	162	my $patron_1 = Koha::Patrons->find( $borrower_id1 );
163	my $borrower_1 = $patron_1->unblessed;
164	my $borrower_id2 = Koha::Patron->new({	163	my $borrower_id2 = Koha::Patron->new({
165	firstname => 'firstname2',	164	firstname => 'firstname2',
166	surname => 'surname2 ',	165	surname => 'surname2 ',
Lines 168-174 my $borrower_id2 = Koha::Patron->new({ Link Here
168	branchcode => $branchcode_2,	167	branchcode => $branchcode_2,
169	})->store->borrowernumber;	168	})->store->borrowernumber;
170	my $patron_2 = Koha::Patrons->find( $borrower_id2 );	169	my $patron_2 = Koha::Patrons->find( $borrower_id2 );
171	my $borrower_2 = $patron_2->unblessed;
172		170
173	t::lib::Mocks::mock_userenv({ patron => $patron_1 });	171	t::lib::Mocks::mock_userenv({ patron => $patron_1 });
174		172
Lines 178-186 t::lib::Mocks::mock_userenv({ patron => $patron_1 }); Link Here
178	my $query = " SELECT count(*) FROM issues";	176	my $query = " SELECT count(*) FROM issues";
179	my $sth = $dbh->prepare($query);	177	my $sth = $dbh->prepare($query);
180	$sth->execute;	178	$sth->execute;
181	my $countissue = $sth -> fetchrow_array;	179	my $countissue = $sth->fetchrow_array;
182	is ($countissue ,0, "there is no issue");	180	is ($countissue ,0, "there is no issue");
183	my $issue1 = C4::Circulation::AddIssue( $borrower_1, $barcode_1, $daysago10,0, $today, '' );	181	my $issue1 = C4::Circulation::AddIssue( $patron_1, $barcode_1, $daysago10, 0, $today, '' );
184	is( ref $issue1, 'Koha::Checkout',	182	is( ref $issue1, 'Koha::Checkout',
185	'AddIssue returns a Koha::Checkout object' );	183	'AddIssue returns a Koha::Checkout object' );
186	my $datedue1 = dt_from_string( $issue1->date_due() );	184	my $datedue1 = dt_from_string( $issue1->date_due() );
Lines 191-201 like( Link Here
191	);	189	);
192	my $issue_id1 = $issue1->issue_id;	190	my $issue_id1 = $issue1->issue_id;
193		191
194	my $issue2 = C4::Circulation::AddIssue( $borrower_1, 'nonexistent_barcode' );	192	my $issue2 = C4::Circulation::AddIssue( $patron_1, 'nonexistent_barcode' );
195	is( $issue2, undef, "AddIssue returns undef if no datedue is specified" );	193	is( $issue2, undef, "AddIssue returns undef if no datedue is specified" );
196		194
197	$sth->execute;	195	$sth->execute;
198	$countissue = $sth -> fetchrow_array;	196	$countissue = $sth->fetchrow_array;
199	is ($countissue,1,"1 issues have been added");	197	is ($countissue,1,"1 issues have been added");
200		198
201	#Test AddIssuingCharge	199	#Test AddIssuingCharge
Lines 263-269 subtest 'Show that AddRenewal respects OpacRenewalBranch and interface' => sub { Link Here
263	my $item = $builder->build_sample_item(	261	my $item = $builder->build_sample_item(
264	{ library => $item_library->branchcode, itype => $itemtype } );	262	{ library => $item_library->branchcode, itype => $itemtype } );
265	my $opac_renew_issue =	263	my $opac_renew_issue =
266	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	264	C4::Circulation::AddIssue( $patron, $item->barcode );
267		265
268	AddRenewal( $patron->borrowernumber, $item->itemnumber,	266	AddRenewal( $patron->borrowernumber, $item->itemnumber,
269	"Stavromula", $datedue1, $daysago10 );	267	"Stavromula", $datedue1, $daysago10 );
Lines 281-287 subtest 'Show that AddRenewal respects OpacRenewalBranch and interface' => sub { Link Here
281	my $item = $builder->build_sample_item(	279	my $item = $builder->build_sample_item(
282	{ library => $item_library->branchcode, itype => $itemtype } );	280	{ library => $item_library->branchcode, itype => $itemtype } );
283	my $opac_renew_issue =	281	my $opac_renew_issue =
284	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	282	C4::Circulation::AddIssue( $patron, $item->barcode );
285		283
286	AddRenewal( $patron->borrowernumber, $item->itemnumber,	284	AddRenewal( $patron->borrowernumber, $item->itemnumber,
287	"Stavromula", $datedue1, $daysago10 );	285	"Stavromula", $datedue1, $daysago10 );
Lines 298-304 subtest 'Show that AddRenewal respects OpacRenewalBranch and interface' => sub { Link Here
298		296
299	my @renewcount;	297	my @renewcount;
300	#Test GetRenewCount	298	#Test GetRenewCount
301	my $issue3 = C4::Circulation::AddIssue( $borrower_1, $barcode_1 );	299	my $issue3 = C4::Circulation::AddIssue( $patron_1, $barcode_1 );
302	#Without anything in DB	300	#Without anything in DB
303	@renewcount = C4::Circulation::GetRenewCount();	301	@renewcount = C4::Circulation::GetRenewCount();
304	is_deeply(	302	is_deeply(
Lines 372-378 my $return = $dbh->selectrow_hashref("SELECT DATE(returndate) AS return_date, CU Link Here
372	ok( $return->{return_date} eq $return->{today}, "Item returned with no return date specified has todays date" );	370	ok( $return->{return_date} eq $return->{today}, "Item returned with no return date specified has todays date" );
373		371
374	$dbh->do("DELETE FROM old_issues");	372	$dbh->do("DELETE FROM old_issues");
375	C4::Circulation::AddIssue( $borrower_1, $barcode_1, $daysago10, 0, $today );	373	C4::Circulation::AddIssue( $patron_1, $barcode_1, $daysago10, 0, $today );
376	AddReturn($barcode_1, undef, undef, dt_from_string('2014-04-01 23:42'));	374	AddReturn($barcode_1, undef, undef, dt_from_string('2014-04-01 23:42'));
377	$return = $dbh->selectrow_hashref("SELECT * FROM old_issues LIMIT 1" );	375	$return = $dbh->selectrow_hashref("SELECT * FROM old_issues LIMIT 1" );
378	ok( $return->{returndate} eq '2014-04-01 23:42:00', "Item returned with a return date of '2014-04-01 23:42' has that return date" );	376	ok( $return->{returndate} eq '2014-04-01 23:42:00', "Item returned with a return date of '2014-04-01 23:42' has that return date" );
Lines 458-464 $item2 = Koha::Items->find( $itemnumber2 ); Link Here
458	ok( $item2->location eq 'CART', q{UpdateItemLocationOnCheckin updates location value from 'GEN' with setting "_ALL_: CART" when transfer filled} );	456	ok( $item2->location eq 'CART', q{UpdateItemLocationOnCheckin updates location value from 'GEN' with setting "_ALL_: CART" when transfer filled} );
459		457
460	ok( $item2->permanent_location eq 'GEN', q{UpdateItemLocationOnCheckin does not update permanent_location value from 'GEN' with setting "_ALL_: CART"} );	458	ok( $item2->permanent_location eq 'GEN', q{UpdateItemLocationOnCheckin does not update permanent_location value from 'GEN' with setting "_ALL_: CART"} );
461	AddIssue( $borrower_1, 'barcode_4', $daysago10,0, $today, '' );	459	AddIssue( $patron_1, 'barcode_4', $daysago10,0, $today, '' );
462	$item2 = Koha::Items->find( $itemnumber2 );	460	$item2 = Koha::Items->find( $itemnumber2 );
463	ok( $item2->location eq 'GEN', q{Location updates from 'CART' to permanent location on issue} );	461	ok( $item2->location eq 'GEN', q{Location updates from 'CART' to permanent location on issue} );
464		462
Lines 507-513 my $reserve_id = AddReserve( Link Here
507	}	505	}
508	);	506	);
509	ok( $reserve_id, 'The reserve should have been inserted' );	507	ok( $reserve_id, 'The reserve should have been inserted' );
510	AddIssue( $borrower_2, $barcode_1, dt_from_string, 'cancel' );	508	AddIssue( $patron_2, $barcode_1, dt_from_string, 'cancel' );
511	my $hold = Koha::Holds->find( $reserve_id );	509	my $hold = Koha::Holds->find( $reserve_id );
512	is( $hold, undef, 'The reserve should have been correctly cancelled' );	510	is( $hold, undef, 'The reserve should have been correctly cancelled' );
513		511
Lines 530-536 my $unseen_library = $builder->build_object( { class => 'Koha::Libraries' } ); Link Here
530	my $unseen_patron = $builder->build_object( { class => 'Koha::Patrons' } );	528	my $unseen_patron = $builder->build_object( { class => 'Koha::Patrons' } );
531	my $unseen_item = $builder->build_sample_item(	529	my $unseen_item = $builder->build_sample_item(
532	{ library => $unseen_library->branchcode, itype => $itemtype } );	530	{ library => $unseen_library->branchcode, itype => $itemtype } );
533	my $unseen_issue = C4::Circulation::AddIssue( $unseen_patron->unblessed, $unseen_item->barcode );	531	my $unseen_issue = C4::Circulation::AddIssue( $unseen_patron, $unseen_item->barcode );
534		532
535	# Does an unseen renewal increment the issue's count	533	# Does an unseen renewal increment the issue's count
536	my ( $unseen_before ) = ( C4::Circulation::GetRenewCount( $unseen_patron->borrowernumber, $unseen_item->itemnumber ) )[3];	534	my ( $unseen_before ) = ( C4::Circulation::GetRenewCount( $unseen_patron->borrowernumber, $unseen_item->itemnumber ) )[3];

Lines 325-333 subtest 'Holds test' => sub { Link Here

(-)a/t/db_dependent/ILSDI_Services.t (-26 / +24 lines)
325		325
326	t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 0 );	326	t::lib::Mocks::mock_preference( 'AllowHoldsOnDamagedItems', 0 );
327		327
328	my $patron = $builder->build({	328	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
329	source => 'Borrower',
330	});
331		329
332	my $item = $builder->build_sample_item(	330	my $item = $builder->build_sample_item(
333	{	331	{
Lines 336-342 subtest 'Holds test' => sub { Link Here
336	);	334	);
337		335
338	my $query = CGI->new;	336	my $query = CGI->new;
339	$query->param( 'patron_id', $patron->{borrowernumber});	337	$query->param( 'patron_id', $patron->borrowernumber);
340	$query->param( 'bib_id', $item->biblionumber);	338	$query->param( 'bib_id', $item->biblionumber);
341		339
342	my $reply = C4::ILSDI::Services::HoldTitle( $query );	340	my $reply = C4::ILSDI::Services::HoldTitle( $query );
Lines 347-353 subtest 'Holds test' => sub { Link Here
347	my $hold = $builder->build({	345	my $hold = $builder->build({
348	source => 'Reserve',	346	source => 'Reserve',
349	value => {	347	value => {
350	borrowernumber => $patron->{borrowernumber},	348	borrowernumber => $patron->borrowernumber,
351	biblionumber => $item->biblionumber,	349	biblionumber => $item->biblionumber,
352	itemnumber => $item->itemnumber	350	itemnumber => $item->itemnumber
353	}	351	}
Lines 359-365 subtest 'Holds test' => sub { Link Here
359	my $biblio_with_no_item = $builder->build_sample_biblio;	357	my $biblio_with_no_item = $builder->build_sample_biblio;
360		358
361	$query = CGI->new;	359	$query = CGI->new;
362	$query->param( 'patron_id', $patron->{borrowernumber});	360	$query->param( 'patron_id', $patron->borrowernumber);
363	$query->param( 'bib_id', $biblio_with_no_item->biblionumber);	361	$query->param( 'bib_id', $biblio_with_no_item->biblionumber);
364		362
365	$reply = C4::ILSDI::Services::HoldTitle( $query );	363	$reply = C4::ILSDI::Services::HoldTitle( $query );
Lines 374-389 subtest 'Holds test' => sub { Link Here
374	t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );	372	t::lib::Mocks::mock_preference( 'ReservesControlBranch', 'PatronLibrary' );
375	Koha::CirculationRules->set_rule(	373	Koha::CirculationRules->set_rule(
376	{	374	{
377	categorycode => $patron->{categorycode},	375	categorycode => $patron->categorycode,
378	itemtype => $item2->{itype},	376	itemtype => $item2->{itype},
379	branchcode => $patron->{branchcode},	377	branchcode => $patron->branchcode,
380	rule_name => 'reservesallowed',	378	rule_name => 'reservesallowed',
381	rule_value => 1,	379	rule_value => 1,
382	}	380	}
383	);	381	);
384		382
385	$query = CGI->new;	383	$query = CGI->new;
386	$query->param( 'patron_id', $patron->{borrowernumber});	384	$query->param( 'patron_id', $patron->borrowernumber);
387	$query->param( 'bib_id', $item2->biblionumber);	385	$query->param( 'bib_id', $item2->biblionumber);
388	$query->param( 'item_id', $item2->itemnumber);	386	$query->param( 'item_id', $item2->itemnumber);
389		387
Lines 392-407 subtest 'Holds test' => sub { Link Here
392		390
393	Koha::CirculationRules->set_rule(	391	Koha::CirculationRules->set_rule(
394	{	392	{
395	categorycode => $patron->{categorycode},	393	categorycode => $patron->categorycode,
396	itemtype => $item2->{itype},	394	itemtype => $item2->{itype},
397	branchcode => $patron->{branchcode},	395	branchcode => $patron->branchcode,
398	rule_name => 'reservesallowed',	396	rule_name => 'reservesallowed',
399	rule_value => 0,	397	rule_value => 0,
400	}	398	}
401	);	399	);
402		400
403	$query = CGI->new;	401	$query = CGI->new;
404	$query->param( 'patron_id', $patron->{borrowernumber});	402	$query->param( 'patron_id', $patron->borrowernumber);
405	$query->param( 'bib_id', $item2->biblionumber);	403	$query->param( 'bib_id', $item2->biblionumber);
406	$query->param( 'item_id', $item2->itemnumber);	404	$query->param( 'item_id', $item2->itemnumber);
407		405
Lines 433-448 subtest 'Holds test' => sub { Link Here
433		431
434	Koha::CirculationRules->set_rule(	432	Koha::CirculationRules->set_rule(
435	{	433	{
436	categorycode => $patron->{categorycode},	434	categorycode => $patron->categorycode,
437	itemtype => $item3->{itype},	435	itemtype => $item3->{itype},
438	branchcode => $patron->{branchcode},	436	branchcode => $patron->branchcode,
439	rule_name => 'reservesallowed',	437	rule_name => 'reservesallowed',
440	rule_value => 10,	438	rule_value => 10,
441	}	439	}
442	);	440	);
443		441
444	$query = CGI->new;	442	$query = CGI->new;
445	$query->param( 'patron_id', $patron->{borrowernumber});	443	$query->param( 'patron_id', $patron->borrowernumber);
446	$query->param( 'bib_id', $item4->biblionumber);	444	$query->param( 'bib_id', $item4->biblionumber);
447	$query->param( 'item_id', $item4->itemnumber);	445	$query->param( 'item_id', $item4->itemnumber);
448		446
Lines 450-461 subtest 'Holds test' => sub { Link Here
450	is( $reply->{code}, 'damaged', "Item is damaged" );	448	is( $reply->{code}, 'damaged', "Item is damaged" );
451		449
452	my $module = Test::MockModule->new('C4::Context');	450	my $module = Test::MockModule->new('C4::Context');
453	$module->mock('userenv', sub { { patron => $patron } });	451	$module->mock('userenv', sub { { patron => $patron->unblessed } });
454	my $issue = C4::Circulation::AddIssue($patron, $item3->barcode);	452	my $issue = C4::Circulation::AddIssue($patron, $item3->barcode);
455	t::lib::Mocks::mock_preference( 'AllowHoldsOnPatronsPossessions', '0' );	453	t::lib::Mocks::mock_preference( 'AllowHoldsOnPatronsPossessions', '0' );
456		454
457	$query = CGI->new;	455	$query = CGI->new;
458	$query->param( 'patron_id', $patron->{borrowernumber});	456	$query->param( 'patron_id', $patron->borrowernumber);
459	$query->param( 'bib_id', $item3->biblionumber);	457	$query->param( 'bib_id', $item3->biblionumber);
460	$query->param( 'item_id', $item3->itemnumber);	458	$query->param( 'item_id', $item3->itemnumber);
461	$query->param( 'pickup_location', $origin_branch->{branchcode});	459	$query->param( 'pickup_location', $origin_branch->{branchcode});
Lines 511-518 subtest 'Holds test for branch transfer limits' => sub { Link Here
511	t::lib::Mocks::mock_preference( 'UseBranchTransferLimits', '1' );	509	t::lib::Mocks::mock_preference( 'UseBranchTransferLimits', '1' );
512	t::lib::Mocks::mock_preference( 'BranchTransferLimitsType', 'itemtype' );	510	t::lib::Mocks::mock_preference( 'BranchTransferLimitsType', 'itemtype' );
513		511
514	my $patron = $builder->build({	512	my $patron = $builder->build_object({
515	source => 'Borrower',	513	class => 'Koha::Patrons',
516	});	514	});
517		515
518	my $origin_branch = $builder->build(	516	my $origin_branch = $builder->build(
Lines 556-562 subtest 'Holds test for branch transfer limits' => sub { Link Here
556		554
557	my $query = CGI->new;	555	my $query = CGI->new;
558	$query->param( 'pickup_location', $pickup_branch->{branchcode} );	556	$query->param( 'pickup_location', $pickup_branch->{branchcode} );
559	$query->param( 'patron_id', $patron->{borrowernumber});	557	$query->param( 'patron_id', $patron->borrowernumber);
560	$query->param( 'bib_id', $item->biblionumber);	558	$query->param( 'bib_id', $item->biblionumber);
561	$query->param( 'item_id', $item->itemnumber);	559	$query->param( 'item_id', $item->itemnumber);
562		560
Lines 570-583 subtest 'Holds test for branch transfer limits' => sub { Link Here
570		568
571	$reply = C4::ILSDI::Services::HoldItem( $query );	569	$reply = C4::ILSDI::Services::HoldItem( $query );
572	is( $reply->{code}, undef, "Item hold, Item can be transferred" );	570	is( $reply->{code}, undef, "Item hold, Item can be transferred" );
573	my $hold = Koha::Holds->search({ itemnumber => $item->itemnumber, borrowernumber => $patron->{borrowernumber} })->next;	571	my $hold = Koha::Holds->search({ itemnumber => $item->itemnumber, borrowernumber => $patron->borrowernumber })->next;
574	is( $hold->branchcode, $pickup_branch->{branchcode}, 'The library id is correctly set' );	572	is( $hold->branchcode, $pickup_branch->{branchcode}, 'The library id is correctly set' );
575		573
576	Koha::Holds->search()->delete();	574	Koha::Holds->search()->delete();
577		575
578	$reply = C4::ILSDI::Services::HoldTitle( $query );	576	$reply = C4::ILSDI::Services::HoldTitle( $query );
579	is( $reply->{code}, undef, "Record hold, Item con be transferred" );	577	is( $reply->{code}, undef, "Record hold, Item con be transferred" );
580	$hold = Koha::Holds->search({ biblionumber => $item->biblionumber, borrowernumber => $patron->{borrowernumber} })->next;	578	$hold = Koha::Holds->search({ biblionumber => $item->biblionumber, borrowernumber => $patron->borrowernumber })->next;
581	is( $hold->branchcode, $pickup_branch->{branchcode}, 'The library id is correctly set' );	579	is( $hold->branchcode, $pickup_branch->{branchcode}, 'The library id is correctly set' );
582		580
583	$schema->storage->txn_rollback;	581	$schema->storage->txn_rollback;
Lines 723-729 subtest 'RenewHold' => sub { Link Here
723	$cgi->param( item_id => $item->itemnumber );	721	$cgi->param( item_id => $item->itemnumber );
724		722
725	t::lib::Mocks::mock_userenv( { patron => $patron } ); # For AddIssue	723	t::lib::Mocks::mock_userenv( { patron => $patron } ); # For AddIssue
726	my $checkout = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	724	my $checkout = C4::Circulation::AddIssue( $patron, $item->barcode );
727		725
728	# Everything is ok	726	# Everything is ok
729	my $reply = C4::ILSDI::Services::RenewLoan($cgi);	727	my $reply = C4::ILSDI::Services::RenewLoan($cgi);
Lines 826-836 subtest 'GetPatronInfo paginated loans' => sub { Link Here
826	my $module = Test::MockModule->new('C4::Context');	824	my $module = Test::MockModule->new('C4::Context');
827	$module->mock('userenv', sub { { branch => $library->branchcode } });	825	$module->mock('userenv', sub { { branch => $library->branchcode } });
828	my $date_due = Koha::DateUtils::dt_from_string()->add(weeks => 2);	826	my $date_due = Koha::DateUtils::dt_from_string()->add(weeks => 2);
829	my $issue1 = C4::Circulation::AddIssue($patron->unblessed, $item1->barcode, $date_due);	827	my $issue1 = C4::Circulation::AddIssue($patron, $item1->barcode, $date_due);
830	my $date_due1 = Koha::DateUtils::dt_from_string( $issue1->date_due );	828	my $date_due1 = Koha::DateUtils::dt_from_string( $issue1->date_due );
831	my $issue2 = C4::Circulation::AddIssue($patron->unblessed, $item2->barcode, $date_due);	829	my $issue2 = C4::Circulation::AddIssue($patron, $item2->barcode, $date_due);
832	my $date_due2 = Koha::DateUtils::dt_from_string( $issue2->date_due );	830	my $date_due2 = Koha::DateUtils::dt_from_string( $issue2->date_due );
833	my $issue3 = C4::Circulation::AddIssue($patron->unblessed, $item3->barcode, $date_due);	831	my $issue3 = C4::Circulation::AddIssue($patron, $item3->barcode, $date_due);
834	my $date_due3 = Koha::DateUtils::dt_from_string( $issue3->date_due );	832	my $date_due3 = Koha::DateUtils::dt_from_string( $issue3->date_due );
835		833
836	my $cgi = CGI->new;	834	my $cgi = CGI->new;

Lines 511-522 subtest 'Renewal related tests' => sub { Link Here

(-)a/t/db_dependent/Koha/Account/Line.t (-9 / +18 lines)
511	class => 'Koha::Checkouts',	511	class => 'Koha::Checkouts',
512	value => {	512	value => {
513	itemnumber => $item->itemnumber,	513	itemnumber => $item->itemnumber,
		514	borrowernumber => $patron->borrowernumber,
514	onsite_checkout => 0,	515	onsite_checkout => 0,
515	renewals_count => 99,	516	renewals_count => 99,
516	auto_renew => 0	517	auto_renew => 0
517	}	518	}
518	}	519	}
519	);	520	);
		521
520	my $line = Koha::Account::Line->new(	522	my $line = Koha::Account::Line->new(
521	{	523	{
522	borrowernumber => $patron->borrowernumber,	524	borrowernumber => $patron->borrowernumber,
Lines 701-707 subtest 'checkout() tests' => sub { Link Here
701	my $account = $patron->account;	703	my $account = $patron->account;
702		704
703	t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });	705	t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode });
704	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	706	my $checkout = AddIssue( $patron, $item->barcode );
705		707
706	my $line = $account->add_debit({	708	my $line = $account->add_debit({
707	amount => 10,	709	amount => 10,
Lines 814-827 subtest "void() tests" => sub { Link Here
814	my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };	816	my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };
815	my $branchcode = $builder->build({ source => 'Branch' })->{ branchcode };	817	my $branchcode = $builder->build({ source => 'Branch' })->{ branchcode };
816		818
817	my $borrower = Koha::Patron->new( {	819	my $staff = $builder->build_object({ class => 'Koha::Patrons' });
818	cardnumber => 'dariahall',	820	t::lib::Mocks::mock_userenv({ patron => $staff });
819	surname => 'Hall',	821
820	firstname => 'Daria',	822	my $borrower = $builder->build_object(
821	} );	823	{
822	$borrower->categorycode( $categorycode );	824	class => 'Koha::Patrons',
823	$borrower->branchcode( $branchcode );	825	value => {
824	$borrower->store;	826	cardnumber => 'dariahall',
		827	surname => 'Hall',
		828	firstname => 'Daria',
		829	categorycode => $categorycode,
		830	branchcode => $branchcode,
		831	}
		832	}
		833	);
825		834
826	my $account = Koha::Account->new({ patron_id => $borrower->id });	835	my $account = Koha::Account->new({ patron_id => $borrower->id });
827		836

Lines 151-159 if ( $code eq 'CHECKIN' ) { Link Here

(-)a/svc/letters/preview (-5 / +2 lines)
151	my $checkout = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );	151	my $checkout = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
152	if ($checkout) {	152	if ($checkout) {
153	my $patron = Koha::Patrons->find( $checkout->borrowernumber );	153	my $patron = Koha::Patrons->find( $checkout->borrowernumber );
154	my $branchcode =	154	my $branchcode = C4::Circulation::_GetCircControlBranch( $item, $patron );
155	C4::Circulation::_GetCircControlBranch( $item->unblessed,
156	$patron->unblessed );
157	$letter_params = {	155	$letter_params = {
158	tables => {	156	tables => {
159	issues => $item->itemnumber,	157	issues => $item->itemnumber,
Lines 177-184 elsif ( $code eq 'CHECKOUT' ) { Link Here
177	my $patron = Koha::Patrons->find( $borrowernumber );	175	my $patron = Koha::Patrons->find( $borrowernumber );
178	if ($item and $patron) {	176	if ($item and $patron) {
179	my $branchcode =	177	my $branchcode =
180	C4::Circulation::_GetCircControlBranch( $item->unblessed,	178	C4::Circulation::_GetCircControlBranch( $item, $patron );
181	$patron->unblessed );
182	$letter_params = {	179	$letter_params = {
183	tables => {	180	tables => {
184	issues => $item->itemnumber,	181	issues => $item->itemnumber,

Lines 18-26 my $schema = Koha::Database->new->schema; Link Here

(-)a/t/db_dependent/Circulation/CalcDateDue.t (-17 / +33 lines)
18	$schema->storage->txn_begin;	18	$schema->storage->txn_begin;
19	my $builder = t::lib::TestBuilder->new;	19	my $builder = t::lib::TestBuilder->new;
20		20
21	my $categorycode = 'B';	21
22	my $itemtype = 'MX';	22	my $library = $builder->build_object({ class => 'Koha::Libraries' })->store;
23	my $branchcode = 'FPL';	23	my $dateexpiry = '2013-01-01';
		24	my $patron_category = $builder->build_object({ class => 'Koha::Patron::Categories', value => { category_type => 'B' } })->store;
		25	my $borrower = $builder->build_object(
		26	{
		27	class => 'Koha::Patrons',
		28	value => {
		29	categorycode => $patron_category->categorycode,
		30	dateexpiry => $dateexpiry,
		31	}
		32	}
		33	)->store;
		34
		35	my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
24	my $issuelength = 10;	36	my $issuelength = 10;
25	my $renewalperiod = 5;	37	my $renewalperiod = 5;
26	my $lengthunit = 'days';	38	my $lengthunit = 'days';
Lines 28-36 my $lengthunit = 'days'; Link Here
28	Koha::CirculationRules->search()->delete();	40	Koha::CirculationRules->search()->delete();
29	Koha::CirculationRules->set_rules(	41	Koha::CirculationRules->set_rules(
30	{	42	{
31	categorycode => $categorycode,	43	categorycode => $patron_category->categorycode,
32	itemtype => $itemtype,	44	itemtype => $itemtype,
33	branchcode => $branchcode,	45	branchcode => $library->branchcode,
34	rules => {	46	rules => {
35	issuelength => $issuelength,	47	issuelength => $issuelength,
36	renewalperiod => $renewalperiod,	48	renewalperiod => $renewalperiod,
Lines 43-55 Koha::CirculationRules->set_rules( Link Here
43	t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 1);	55	t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 1);
44	t::lib::Mocks::mock_preference('useDaysMode', 'Days');	56	t::lib::Mocks::mock_preference('useDaysMode', 'Days');
45		57
		58	my $branchcode = $library->branchcode;
		59
46	my $cache = Koha::Caches->get_instance();	60	my $cache = Koha::Caches->get_instance();
47	my $key = $branchcode . "_holidays";	61	my $key = $branchcode . "_holidays";
48	$cache->clear_from_cache($key);	62	$cache->clear_from_cache($key);
49		63
50	my $dateexpiry = '2013-01-01';
51
52	my $borrower = {categorycode => 'B', dateexpiry => $dateexpiry};
53	my $start_date = DateTime->new({year => 2013, month => 2, day => 9});	64	my $start_date = DateTime->new({year => 2013, month => 2, day => 9});
54	my $date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );	65	my $date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );
55	is($date, $dateexpiry . 'T23:59:00', 'date expiry');	66	is($date, $dateexpiry . 'T23:59:00', 'date expiry');
Lines 60-66 $date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borr Link Here
60	t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 1);	71	t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 1);
61	t::lib::Mocks::mock_preference('useDaysMode', 'noDays');	72	t::lib::Mocks::mock_preference('useDaysMode', 'noDays');
62		73
63	$borrower = {categorycode => 'B', dateexpiry => $dateexpiry};
64	$start_date = DateTime->new({year => 2013, month => 2, day => 9});	74	$start_date = DateTime->new({year => 2013, month => 2, day => 9});
65	$date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );	75	$date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );
66	is($date, $dateexpiry . 'T23:59:00', 'date expiry with useDaysMode to noDays');	76	is($date, $dateexpiry . 'T23:59:00', 'date expiry with useDaysMode to noDays');
Lines 95-101 $date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borr Link Here
95	t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 0);	105	t::lib::Mocks::mock_preference('ReturnBeforeExpiry', 0);
96	t::lib::Mocks::mock_preference('useDaysMode', 'Days');	106	t::lib::Mocks::mock_preference('useDaysMode', 'Days');
97		107
98	$borrower = {categorycode => 'B', dateexpiry => $dateexpiry};
99	$start_date = DateTime->new({year => 2013, month => 2, day => 9});	108	$start_date = DateTime->new({year => 2013, month => 2, day => 9});
100	$date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );	109	$date = C4::Circulation::CalcDateDue( $start_date, $itemtype, $branchcode, $borrower );
101	is($date, '2013-02-' . (9 + $issuelength) . 'T23:59:00', "date expiry ( 9 + $issuelength )");	110	is($date, '2013-02-' . (9 + $issuelength) . 'T23:59:00', "date expiry ( 9 + $issuelength )");
Lines 158-175 $calendar->delete_holiday( Link Here
158		167
159	# Now we test it does the right thing if the loan and renewal periods	168	# Now we test it does the right thing if the loan and renewal periods
160	# are a multiple of 7 days	169	# are a multiple of 7 days
161	my $dayweek_categorycode = 'K';
162	my $dayweek_itemtype = 'MX';
163	my $dayweek_branchcode = 'FPL';
164	my $dayweek_issuelength = 14;	170	my $dayweek_issuelength = 14;
165	my $dayweek_renewalperiod = 7;	171	my $dayweek_renewalperiod = 7;
166	my $dayweek_lengthunit = 'days';	172	my $dayweek_lengthunit = 'days';
167		173
		174	$patron_category = $builder->build_object({ class => 'Koha::Patron::Categories', value => { category_type => 'K' } })->store;
		175
168	Koha::CirculationRules->set_rules(	176	Koha::CirculationRules->set_rules(
169	{	177	{
170	categorycode => $dayweek_categorycode,	178	categorycode => $patron_category->categorycode,
171	itemtype => $dayweek_itemtype,	179	itemtype => $itemtype,
172	branchcode => $dayweek_branchcode,	180	branchcode => $branchcode,
173	rules => {	181	rules => {
174	issuelength => $dayweek_issuelength,	182	issuelength => $dayweek_issuelength,
175	renewalperiod => $dayweek_renewalperiod,	183	renewalperiod => $dayweek_renewalperiod,
Lines 178-184 Koha::CirculationRules->set_rules( Link Here
178	}	186	}
179	);	187	);
180		188
181	my $dayweek_borrower = {categorycode => 'K', dateexpiry => $dateexpiry};	189	my $dayweek_borrower = $builder->build_object(
		190	{
		191	class => 'Koha::Patrons',
		192	value => {
		193	categorycode => $patron_category->categorycode,
		194	dateexpiry => $dateexpiry,
		195	}
		196	}
		197	);
182		198
183	# For issues...	199	# For issues...
184	$start_date = DateTime->new({year => 2013, month => 2, day => 9});	200	$start_date = DateTime->new({year => 2013, month => 2, day => 9});

Lines 66-76 my ($biblionumber2) = AddBiblio(MARC::Record->new, ''); Link Here

(-)a/t/db_dependent/Circulation/CheckIfIssuedToPatron.t (-7 / +27 lines)
66	my $barcode2 = '0202';	66	my $barcode2 = '0202';
67	Koha::Item->new({ barcode => $barcode2, %item_info, biblionumber => $biblionumber2 })->store;	67	Koha::Item->new({ barcode => $barcode2, %item_info, biblionumber => $biblionumber2 })->store;
68		68
69	my $borrowernumber1 = Koha::Patron->new({categorycode => $categorycode, branchcode => $branchcode})->store->borrowernumber;	69	my $patron1 = $builder->build_object(
70	my $borrowernumber2 = Koha::Patron->new({categorycode => $categorycode, branchcode => $branchcode})->store->borrowernumber;	70	{
71	# FIXME following code must be simplified to use the Koha::Patron objects	71	class => 'Koha::Patrons'
72	my $borrower1 = Koha::Patrons->find( $borrowernumber1 )->unblessed;	72	value => {
73	my $borrower2 = Koha::Patrons->find( $borrowernumber2 )->unblessed;	73	{
		74	categorycode => $categorycode,
		75	branchcode => $branchcode
		76	}
		77	}
		78	}
		79	);
		80	my $patron2 = $builder->build_object(
		81	{
		82	class => 'Koha::Patrons'
		83	value => {
		84	{
		85	categorycode => $categorycode,
		86	branchcode => $branchcode
		87	}
		88	}
		89	}
		90	);
		91
		92	my $borrowernumber1 = $patron1->borrowernumber;
		93	my $borrowernumber2 = $patron2->borrowernumber;
74		94
75	my $module = Test::MockModule->new('C4::Context');	95	my $module = Test::MockModule->new('C4::Context');
76	$module->mock('userenv', sub { { branch => $branchcode } });	96	$module->mock('userenv', sub { { branch => $branchcode } });
Lines 91-97 is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' ); Link Here
91	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron($borrowernumber2, $biblionumber2);	111	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron($borrowernumber2, $biblionumber2);
92	is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' );	112	is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' );
93		113
94	AddIssue($borrower1, '0101');	114	AddIssue($patron1, '0101');
95	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron();	115	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron();
96	is( $check_if_issued, undef, 'CheckIfIssuedToPatron without argument returns undef' );	116	is( $check_if_issued, undef, 'CheckIfIssuedToPatron without argument returns undef' );
97	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron(undef, $biblionumber1);	117	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron(undef, $biblionumber1);
Lines 107-113 is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' ); Link Here
107	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron($borrowernumber2, $biblionumber2);	127	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron($borrowernumber2, $biblionumber2);
108	is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' );	128	is( $check_if_issued, undef, 'CheckIfIssuedToPatron returns undef' );
109		129
110	AddIssue($borrower2, '0202');	130	AddIssue($patron2, '0202');
111	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron();	131	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron();
112	is( $check_if_issued, undef, 'CheckIfIssuedToPatron without argument returns undef' );	132	is( $check_if_issued, undef, 'CheckIfIssuedToPatron without argument returns undef' );
113	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron(undef, $biblionumber1);	133	$check_if_issued = C4::Circulation::CheckIfIssuedToPatron(undef, $biblionumber1);

Lines 57-82 my ($biblionumber2) = AddBiblio(MARC::Record->new, ''); Link Here

(-)a/t/db_dependent/Circulation/GetPendingOnSiteCheckouts.t (-8 / +6 lines)
57	my $itemnumber3 = Koha::Item->new({ barcode => '0203', %item_infos, biblionumber => $biblionumber2})->store->itemnumber;	57	my $itemnumber3 = Koha::Item->new({ barcode => '0203', %item_infos, biblionumber => $biblionumber2})->store->itemnumber;
58		58
59	my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };	59	my $categorycode = $builder->build({ source => 'Category' })->{ categorycode };
60	my $borrowernumber = $builder->build(	60	my $patron = $builder->build_object(
61	{ source => 'Borrower',	61	{ class => 'Koha::Patrons',
62	value => { categorycode => $categorycode, branchcode => $branchcode }	62	value => { categorycode => $categorycode, branchcode => $branchcode }
63	}	63	}
64	)->{borrowernumber};	64	);
65
66	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;
67		65
68	# Need to mock userenv for AddIssue	66	# Need to mock userenv for AddIssue
69	my $module = Test::MockModule->new('C4::Context');	67	my $module = Test::MockModule->new('C4::Context');
70	$module->mock('userenv', sub { { branch => $branchcode } });	68	$module->mock('userenv', sub { { branch => $branchcode } });
71	AddIssue($borrower, '0101');	69	AddIssue($patron, '0101');
72	AddIssue($borrower, '0203');	70	AddIssue($patron, '0203');
73		71
74	# Begin tests...	72	# Begin tests...
75	my $onsite_checkouts = GetPendingOnSiteCheckouts;	73	my $onsite_checkouts = GetPendingOnSiteCheckouts;
76	is( scalar @$onsite_checkouts, 0, "No pending on-site checkouts" );	74	is( scalar @$onsite_checkouts, 0, "No pending on-site checkouts" );
77		75
78	my $itemnumber4 = Koha::Item->new({ barcode => '0104', %item_infos, biblionumber => $biblionumber1})->store->itemnumber;	76	my $itemnumber4 = Koha::Item->new({ barcode => '0104', %item_infos, biblionumber => $biblionumber1})->store->itemnumber;
79	AddIssue( $borrower, '0104', undef, undef, undef, undef, { onsite_checkout => 1 } );	77	AddIssue( $patron, '0104', undef, undef, undef, undef, { onsite_checkout => 1 } );
80	$onsite_checkouts = GetPendingOnSiteCheckouts;	78	$onsite_checkouts = GetPendingOnSiteCheckouts;
81	is( scalar @$onsite_checkouts, 1, "There is 1 pending on-site checkout" );	79	is( scalar @$onsite_checkouts, 1, "There is 1 pending on-site checkout" );
82		80

Lines 42-55 my $patron_category = $builder->build({ source => 'Category' }); Link Here

(-)a/t/db_dependent/Circulation/IsItemIssued.t (-3 / +3 lines)
42		42
43	t::lib::Mocks::mock_userenv({ branchcode => $library->{branchcode} });	43	t::lib::Mocks::mock_userenv({ branchcode => $library->{branchcode} });
44		44
45	my $borrowernumber = Koha::Patron->new({	45	my $borrower = Koha::Patron->new({
46	firstname => 'my firstname',	46	firstname => 'my firstname',
47	surname => 'my surname',	47	surname => 'my surname',
48	categorycode => $patron_category->{categorycode},	48	categorycode => $patron_category->{categorycode},
49	branchcode => $library->{branchcode},	49	branchcode => $library->{branchcode},
50	})->store->borrowernumber;	50	})->store;
		51
51		52
52	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;
53	my $record = MARC::Record->new();	53	my $record = MARC::Record->new();
54	my ( $biblionumber, $biblioitemnumber ) = AddBiblio( $record, '' );	54	my ( $biblionumber, $biblioitemnumber ) = AddBiblio( $record, '' );
55		55

Lines 63-69 subtest 'Failure tests' => sub { Link Here

(-)a/t/db_dependent/Circulation/MarkIssueReturned.t (-8 / +8 lines)
63	is( $issue_id, undef, 'No issue_id returned' );	63	is( $issue_id, undef, 'No issue_id returned' );
64		64
65	# In the next call we return the item and try it another time	65	# In the next call we return the item and try it another time
66	$issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	66	$issue = C4::Circulation::AddIssue( $patron, $item->barcode );
67	eval { $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0 ) };	67	eval { $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0 ) };
68	is( $issue_id, $issue->issue_id, "Item has been returned (issue $issue_id)" );	68	is( $issue_id, $issue->issue_id, "Item has been returned (issue $issue_id)" );
69	eval { $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0 ) };	69	eval { $issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 0 ) };
Lines 98-104 subtest 'Anonymous patron tests' => sub { Link Here
98	# Anonymous patron not set	98	# Anonymous patron not set
99	t::lib::Mocks::mock_preference( 'AnonymousPatron', '' );	99	t::lib::Mocks::mock_preference( 'AnonymousPatron', '' );
100		100
101	my $issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	101	my $issue = C4::Circulation::AddIssue( $patron, $item->barcode );
102		102
103	throws_ok	103	throws_ok
104	{ C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 2 ); }	104	{ C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 2 ); }
Lines 117-123 subtest 'Anonymous patron tests' => sub { Link Here
117	}	117	}
118	});	118	});
119	t::lib::Mocks::mock_preference('AnonymousPatron', $anonymous->borrowernumber);	119	t::lib::Mocks::mock_preference('AnonymousPatron', $anonymous->borrowernumber);
120	$issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	120	$issue = C4::Circulation::AddIssue( $patron, $item->barcode );
121		121
122	eval { C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 2 ) };	122	eval { C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, undef, 2 ) };
123	is ( $@, q\|\|, 'AnonymousPatron is set correctly - no error expected');	123	is ( $@, q\|\|, 'AnonymousPatron is set correctly - no error expected');
Lines 148-161 subtest 'Manually pass a return date' => sub { Link Here
148		148
149	my ( $issue, $issue_id );	149	my ( $issue, $issue_id );
150		150
151	$issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	151	$issue = C4::Circulation::AddIssue( $patron, $item->barcode );
152	$issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, '2018-12-25', 0 );	152	$issue_id = C4::Circulation::MarkIssueReturned( $patron->borrowernumber, $item->itemnumber, '2018-12-25', 0 );
153		153
154	is( $issue_id, $issue->issue_id, "Item has been returned" );	154	is( $issue_id, $issue->issue_id, "Item has been returned" );
155	my $old_checkout = Koha::Old::Checkouts->find( $issue_id );	155	my $old_checkout = Koha::Old::Checkouts->find( $issue_id );
156	is( $old_checkout->returndate, '2018-12-25 00:00:00', 'Manually passed date stored correctly' );	156	is( $old_checkout->returndate, '2018-12-25 00:00:00', 'Manually passed date stored correctly' );
157		157
158	$issue = C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	158	$issue = C4::Circulation::AddIssue( $patron, $item->barcode );
159		159
160	{	160	{
161	# Hiding the expected warning displayed by DBI	161	# Hiding the expected warning displayed by DBI
Lines 185-193 subtest 'AutoRemoveOverduesRestrictions' => sub { Link Here
185	my $item_2 = $builder->build_sample_item;	185	my $item_2 = $builder->build_sample_item;
186	my $item_3 = $builder->build_sample_item;	186	my $item_3 = $builder->build_sample_item;
187	my $five_days_ago = dt_from_string->subtract( days => 5 );	187	my $five_days_ago = dt_from_string->subtract( days => 5 );
188	my $checkout_1 = AddIssue( $patron->unblessed, $item_1->barcode, $five_days_ago ); # overdue	188	my $checkout_1 = AddIssue( $patron, $item_1->barcode, $five_days_ago ); # overdue
189	my $checkout_2 = AddIssue( $patron->unblessed, $item_2->barcode, $five_days_ago ); # overdue	189	my $checkout_2 = AddIssue( $patron, $item_2->barcode, $five_days_ago ); # overdue
190	my $checkout_3 = AddIssue( $patron->unblessed, $item_3->barcode ); # not overdue	190	my $checkout_3 = AddIssue( $patron, $item_3->barcode ); # not overdue
191		191
192	Koha::Patron::Debarments::AddUniqueDebarment(	192	Koha::Patron::Debarments::AddUniqueDebarment(
193	{	193	{

Lines 65-71 subtest 'Test Koha::Checkout::claim_returned, do not mark as returned' => sub { Link Here

(-)a/t/db_dependent/Circulation/ReturnClaims.t (-3 / +3 lines)
65	t::lib::Mocks::mock_preference( 'MarkLostItemsAsReturned', q{} );	65	t::lib::Mocks::mock_preference( 'MarkLostItemsAsReturned', q{} );
66	my $item = $builder->build_sample_item;	66	my $item = $builder->build_sample_item;
67	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );	67	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
68	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	68	my $checkout = AddIssue( $patron, $item->barcode );
69		69
70	my $claim = $checkout->claim_returned(	70	my $claim = $checkout->claim_returned(
71	{	71	{
Lines 91-97 subtest 'Test Koha::Patronn::return_claims' => sub { Link Here
91	t::lib::Mocks::mock_preference( 'ClaimReturnedLostValue', 1 );	91	t::lib::Mocks::mock_preference( 'ClaimReturnedLostValue', 1 );
92	my $item = $builder->build_sample_item;	92	my $item = $builder->build_sample_item;
93	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );	93	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
94	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	94	my $checkout = AddIssue( $patron, $item->barcode );
95		95
96	$checkout->claim_returned(	96	$checkout->claim_returned(
97	{	97	{
Lines 121-127 subtest 'Test Koha::Checkout::claim_returned, mark as returned' => sub { Link Here
121	t::lib::Mocks::mock_preference( 'MarkLostItemsAsReturned', q{claim_returned} );	121	t::lib::Mocks::mock_preference( 'MarkLostItemsAsReturned', q{claim_returned} );
122	my $item = $builder->build_sample_item;	122	my $item = $builder->build_sample_item;
123	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );	123	my $patron = $builder->build_object( { class => 'Koha::Patrons' } );
124	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	124	my $checkout = AddIssue( $patron, $item->barcode );
125		125
126	my $claim = $checkout->claim_returned(	126	my $claim = $checkout->claim_returned(
127	{	127	{

Lines 86-95 subtest "AddReturn logging on statistics table (item-level_itypes=1)" => sub { Link Here

(-)a/t/db_dependent/Circulation/Returns.t (-22 / +21 lines)
86	# Create a branch	86	# Create a branch
87	$branch = $builder->build({ source => 'Branch' })->{ branchcode };	87	$branch = $builder->build({ source => 'Branch' })->{ branchcode };
88	# Create a borrower	88	# Create a borrower
89	my $borrowernumber = $builder->build({	89	my $patron = $builder->build_object({
90	source => 'Borrower',	90	class => 'Koha::Patrons',
91	value => { branchcode => $branch }	91	value => { branchcode => $branch }
92	})->{ borrowernumber };	92	});
93	# Look for the defined MARC field for biblio-level itemtype	93	# Look for the defined MARC field for biblio-level itemtype
94	my $rs = $schema->resultset('MarcSubfieldStructure')->search({	94	my $rs = $schema->resultset('MarcSubfieldStructure')->search({
95	frameworkcode => '',	95	frameworkcode => '',
Lines 118-125 subtest "AddReturn logging on statistics table (item-level_itypes=1)" => sub { Link Here
118	}	118	}
119	)->_result->update({ itype => undef });	119	)->_result->update({ itype => undef });
120		120
121	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;	121	AddIssue( $patron, $item_with_itemtype->barcode );
122	AddIssue( $borrower, $item_with_itemtype->barcode );
123	AddReturn( $item_with_itemtype->barcode, $branch );	122	AddReturn( $item_with_itemtype->barcode, $branch );
124	# Test item-level itemtype was recorded on the 'statistics' table	123	# Test item-level itemtype was recorded on the 'statistics' table
125	my $stat = $schema->resultset('Statistic')->search({	124	my $stat = $schema->resultset('Statistic')->search({
Lines 130-137 subtest "AddReturn logging on statistics table (item-level_itypes=1)" => sub { Link Here
130		129
131	is( $stat->itemtype, $ilevel_itemtype,	130	is( $stat->itemtype, $ilevel_itemtype,
132	"item-level itype recorded on statistics for return");	131	"item-level itype recorded on statistics for return");
133	warning_like { AddIssue( $borrower, $item_without_itemtype->barcode ) }	132	warning_like { AddIssue( $patron, $item_without_itemtype->barcode ) }
134	[qr/^item-level_itypes set but no itemtype set for item/,	133	[qr/^item-level_itypes set but no itemtype set for item/,
		134	qr/^item-level_itypes set but no itemtype set for item/,
135	qr/^item-level_itypes set but no itemtype set for item/],	135	qr/^item-level_itypes set but no itemtype set for item/],
136	'Item without itemtype set raises warning on AddIssue';	136	'Item without itemtype set raises warning on AddIssue';
137	AddReturn( $item_without_itemtype->barcode, $branch );	137	AddReturn( $item_without_itemtype->barcode, $branch );
Lines 165-172 subtest "AddReturn logging on statistics table (item-level_itypes=0)" => sub { Link Here
165	# Create a branch	165	# Create a branch
166	$branch = $builder->build({ source => 'Branch' })->{ branchcode };	166	$branch = $builder->build({ source => 'Branch' })->{ branchcode };
167	# Create a borrower	167	# Create a borrower
168	my $borrowernumber = $builder->build({	168	my $patron = $builder->build_object({
169	source => 'Borrower',	169	class => 'Koha::Patrons',
170	value => { branchcode => $branch }	170	value => { branchcode => $branch }
171	})->{ borrowernumber };	171	})->{ borrowernumber };
172	# Look for the defined MARC field for biblio-level itemtype	172	# Look for the defined MARC field for biblio-level itemtype
Lines 198-206 subtest "AddReturn logging on statistics table (item-level_itypes=0)" => sub { Link Here
198	}	198	}
199	);	199	);
200		200
201	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;	201	AddIssue( $patron, $item_with_itemtype->barcode );
202
203	AddIssue( $borrower, $item_with_itemtype->barcode );
204	AddReturn( $item_with_itemtype->barcode, $branch );	202	AddReturn( $item_with_itemtype->barcode, $branch );
205	# Test item-level itemtype was recorded on the 'statistics' table	203	# Test item-level itemtype was recorded on the 'statistics' table
206	my $stat = $schema->resultset('Statistic')->search({	204	my $stat = $schema->resultset('Statistic')->search({
Lines 212-218 subtest "AddReturn logging on statistics table (item-level_itypes=0)" => sub { Link Here
212	is( $stat->itemtype, $blevel_itemtype,	210	is( $stat->itemtype, $blevel_itemtype,
213	"biblio-level itype recorded on statistics for return");	211	"biblio-level itype recorded on statistics for return");
214		212
215	AddIssue( $borrower, $item_without_itemtype->barcode );	213	AddIssue( $patron, $item_without_itemtype->barcode );
216	AddReturn( $item_without_itemtype->barcode, $branch );	214	AddReturn( $item_without_itemtype->barcode, $branch );
217	# Test biblio-level itemtype was recorded on the 'statistics' table	215	# Test biblio-level itemtype was recorded on the 'statistics' table
218	$stat = $schema->resultset('Statistic')->search({	216	$stat = $schema->resultset('Statistic')->search({
Lines 250-259 subtest 'Handle ids duplication' => sub { Link Here
250	itype => $itemtype->{itemtype},	248	itype => $itemtype->{itemtype},
251	}	249	}
252	);	250	);
253	my $patron = $builder->build({source => 'Borrower'});	251	my $patron = $builder->build_object(
254	$patron = Koha::Patrons->find( $patron->{borrowernumber} );	252	{ class => 'Koha::Patrons'}
		253	);
255		254
256	my $original_checkout = AddIssue( $patron->unblessed, $item->barcode, dt_from_string->subtract( days => 50 ) );	255	my $original_checkout = AddIssue( $patron, $item->barcode, dt_from_string->subtract( days => 50 ) );
257	my $issue_id = $original_checkout->issue_id;	256	my $issue_id = $original_checkout->issue_id;
258	my $account_lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber, issue_id => $issue_id });	257	my $account_lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber, issue_id => $issue_id });
259	is( $account_lines->count, 1, '1 account line should exist for this issue_id' );	258	is( $account_lines->count, 1, '1 account line should exist for this issue_id' );
Lines 280-286 subtest 'Handle ids duplication' => sub { Link Here
280	is( $messages->{WasReturned}, 0, 'messages should have the WasReturned flag set to 0' );	279	is( $messages->{WasReturned}, 0, 'messages should have the WasReturned flag set to 0' );
281	is( $messages->{DataCorrupted}, 1, 'messages should have the DataCorrupted flag set to 1' );	280	is( $messages->{DataCorrupted}, 1, 'messages should have the DataCorrupted flag set to 1' );
282		281
283	$account_lines = Koha::Account::Lines->search({ borrowernumber => $patron->borrowernumber, issue_id => $issue_id });	282	$account_lines = Koha::Account::Lines->search({ borrowernumber => $borrower->{borrowernumber}, issue_id => $issue_id });
284	is( $account_lines->count, 0, 'No account lines should exist for this issue_id, patron should not have been charged' );	283	is( $account_lines->count, 0, 'No account lines should exist for this issue_id, patron should not have been charged' );
285		284
286	is( Koha::Checkouts->find( $issue_id )->issue_id, $issue_id, 'The issues entry should not have been removed' );	285	is( Koha::Checkouts->find( $issue_id )->issue_id, $issue_id, 'The issues entry should not have been removed' );
Lines 289-296 subtest 'Handle ids duplication' => sub { Link Here
289	subtest 'BlockReturnOfLostItems' => sub {	288	subtest 'BlockReturnOfLostItems' => sub {
290	plan tests => 4;	289	plan tests => 4;
291	my $item = $builder->build_sample_item;	290	my $item = $builder->build_sample_item;
292	my $patron = $builder->build_object({class => 'Koha::Patrons'});	291	my $patron = $builder->build_object({ class => 'Koha::Patrons' });
293	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	292	my $checkout = AddIssue( $patron, $item->barcode );
294		293
295	# Mark the item as lost	294	# Mark the item as lost
296	$item->itemlost(1)->store;	295	$item->itemlost(1)->store;
Lines 314-320 subtest 'Checkin of an item claimed as returned should generate a message' => su Link Here
314	t::lib::Mocks::mock_preference('ClaimReturnedLostValue', 1);	313	t::lib::Mocks::mock_preference('ClaimReturnedLostValue', 1);
315	my $item = $builder->build_sample_item;	314	my $item = $builder->build_sample_item;
316	my $patron = $builder->build_object({class => 'Koha::Patrons'});	315	my $patron = $builder->build_object({class => 'Koha::Patrons'});
317	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	316	my $checkout = AddIssue( $patron, $item->barcode );
318		317
319	$checkout->claim_returned({ created_by => $patron->id });	318	$checkout->claim_returned({ created_by => $patron->id });
320		319
Lines 331-342 subtest 'BranchTransferLimitsType' => sub { Link Here
331		330
332	my $item = $builder->build_sample_item;	331	my $item = $builder->build_sample_item;
333	my $patron = $builder->build_object({class => 'Koha::Patrons'});	332	my $patron = $builder->build_object({class => 'Koha::Patrons'});
334	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	333	my $checkout = AddIssue( $patron, $item->barcode );
335	my ( $doreturn, $messages, $issue ) = AddReturn($item->barcode);	334	my ( $doreturn, $messages, $issue ) = AddReturn($item->barcode);
336	is( $doreturn, 1, 'AddReturn should have checkin the item if BranchTransferLimitsType=ccode');	335	is( $doreturn, 1, 'AddReturn should have checkin the item if BranchTransferLimitsType=ccode');
337		336
338	t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');	337	t::lib::Mocks::mock_preference('BranchTransferLimitsType', 'itemtype');
339	$checkout = AddIssue( $patron->unblessed, $item->barcode );	338	$checkout = AddIssue( $patron, $item->barcode );
340	( $doreturn, $messages, $issue ) = AddReturn($item->barcode);	339	( $doreturn, $messages, $issue ) = AddReturn($item->barcode);
341	is( $doreturn, 1, 'AddReturn should have checkin the item if BranchTransferLimitsType=itemtype');	340	is( $doreturn, 1, 'AddReturn should have checkin the item if BranchTransferLimitsType=itemtype');
342	};	341	};
Lines 350-356 subtest 'Backdated returns should reduce fine if needed' => sub { Link Here
350	my $biblio = $builder->build_object( { class => 'Koha::Biblios' } );	349	my $biblio = $builder->build_object( { class => 'Koha::Biblios' } );
351	my $item = $builder->build_sample_item;	350	my $item = $builder->build_sample_item;
352	my $patron = $builder->build_object({class => 'Koha::Patrons'});	351	my $patron = $builder->build_object({class => 'Koha::Patrons'});
353	my $checkout = AddIssue( $patron->unblessed, $item->barcode );	352	my $checkout = AddIssue( $patron, $item->barcode );
354	my $fine = Koha::Account::Line->new({	353	my $fine = Koha::Account::Line->new({
355	issue_id => $checkout->id,	354	issue_id => $checkout->id,
356	borrowernumber => $patron->id,	355	borrowernumber => $patron->id,

Lines 55-61 my $patron = $builder->build_object({ Link Here

(-)a/t/db_dependent/Circulation/SwitchOnSiteCheckouts.t (-4 / +3 lines)
55	categorycode => $patron_category->{categorycode},	55	categorycode => $patron_category->{categorycode},
56	},	56	},
57	});	57	});
58	my $patron_unblessed = $patron->unblessed;
59		58
60	my $item = $builder->build_sample_item(	59	my $item = $builder->build_sample_item(
61	{	60	{
Lines 85-91 t::lib::Mocks::mock_userenv({ patron => $patron }); Link Here
85	t::lib::Mocks::mock_preference('AllowTooManyOverride', 0);	84	t::lib::Mocks::mock_preference('AllowTooManyOverride', 0);
86		85
87	# Add onsite checkout	86	# Add onsite checkout
88	C4::Circulation::AddIssue( $patron_unblessed, $item->barcode, dt_from_string, undef, dt_from_string, undef, { onsite_checkout => 1 } );	87	C4::Circulation::AddIssue( $patron, $item->barcode, dt_from_string, undef, dt_from_string, undef, { onsite_checkout => 1 } );
89		88
90	my ( $impossible, $messages );	89	my ( $impossible, $messages );
91	t::lib::Mocks::mock_preference('SwitchOnSiteCheckouts', 0);	90	t::lib::Mocks::mock_preference('SwitchOnSiteCheckouts', 0);
Lines 96-102 t::lib::Mocks::mock_preference('SwitchOnSiteCheckouts', 1); Link Here
96	( $impossible, undef, undef, $messages ) = C4::Circulation::CanBookBeIssued( $patron, $item->barcode );	95	( $impossible, undef, undef, $messages ) = C4::Circulation::CanBookBeIssued( $patron, $item->barcode );
97	is( $messages->{ONSITE_CHECKOUT_WILL_BE_SWITCHED}, 1, 'If SwitchOnSiteCheckouts, switch the on-site checkout' );	96	is( $messages->{ONSITE_CHECKOUT_WILL_BE_SWITCHED}, 1, 'If SwitchOnSiteCheckouts, switch the on-site checkout' );
98	is( exists $impossible->{TOO_MANY}, '', 'If SwitchOnSiteCheckouts, switch the on-site checkout' );	97	is( exists $impossible->{TOO_MANY}, '', 'If SwitchOnSiteCheckouts, switch the on-site checkout' );
99	C4::Circulation::AddIssue( $patron_unblessed, $item->barcode, undef, undef, undef, undef, { switch_onsite_checkout => 1 } );	98	C4::Circulation::AddIssue( $patron, $item->barcode, undef, undef, undef, undef, { switch_onsite_checkout => 1 } );
100	my $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );	99	my $issue = Koha::Checkouts->find( { itemnumber => $item->itemnumber } );
101	is( $issue->onsite_checkout, 0, 'The issue should have been switched to a regular checkout' );	100	is( $issue->onsite_checkout, 0, 'The issue should have been switched to a regular checkout' );
102	my $five_days_after = dt_from_string->add( days => 5 )->set( hour => 23, minute => 59, second => 0 );	101	my $five_days_after = dt_from_string->add( days => 5 )->set( hour => 23, minute => 59, second => 0 );
Lines 111-117 my $another_item = $builder->build_sample_item( Link Here
111	}	110	}
112	);	111	);
113		112
114	C4::Circulation::AddIssue( $patron_unblessed, $another_item->barcode, dt_from_string, undef, dt_from_string, undef, { onsite_checkout => 1 } );	113	C4::Circulation::AddIssue( $patron, $another_item->barcode, dt_from_string, undef, dt_from_string, undef, { onsite_checkout => 1 } );
115	( $impossible, undef, undef, $messages ) = C4::Circulation::CanBookBeIssued( $patron, $another_item->barcode );	114	( $impossible, undef, undef, $messages ) = C4::Circulation::CanBookBeIssued( $patron, $another_item->barcode );
116	is( $messages->{ONSITE_CHECKOUT_WILL_BE_SWITCHED}, 1, 'Specific case 1 - Switch is allowed' );	115	is( $messages->{ONSITE_CHECKOUT_WILL_BE_SWITCHED}, 1, 'Specific case 1 - Switch is allowed' );
117	is( exists $impossible->{TOO_MANY}, '', 'Specific case 1 - Switch is allowed' );	116	is( exists $impossible->{TOO_MANY}, '', 'Specific case 1 - Switch is allowed' );

Lines 39-45 our $dbh = C4::Context->dbh; Link Here

(-)a/t/db_dependent/Circulation/TooMany.t (-9 / +8 lines)
39	$dbh->do(q\|DELETE FROM issues\|);	39	$dbh->do(q\|DELETE FROM issues\|);
40	$dbh->do(q\|DELETE FROM items\|);	40	$dbh->do(q\|DELETE FROM items\|);
41	$dbh->do(q\|DELETE FROM borrowers\|);	41	$dbh->do(q\|DELETE FROM borrowers\|);
42	$dbh->do(q\|DELETE FROM branches\|);	42	#$dbh->do(q\|DELETE FROM branches\|);
43	$dbh->do(q\|DELETE FROM categories\|);	43	$dbh->do(q\|DELETE FROM categories\|);
44	$dbh->do(q\|DELETE FROM accountlines\|);	44	$dbh->do(q\|DELETE FROM accountlines\|);
45	$dbh->do(q\|DELETE FROM itemtypes\|);	45	$dbh->do(q\|DELETE FROM itemtypes\|);
Lines 60-67 my $category = $builder->build({ Link Here
60	source => 'Category',	60	source => 'Category',
61	});	61	});
62		62
63	my $patron = $builder->build({	63	my $patron = $builder->build_object({
64	source => 'Borrower',	64	class => 'Koha::Patrons',
65	value => {	65	value => {
66	categorycode => $category->{categorycode},	66	categorycode => $category->{categorycode},
67	branchcode => $branch->{branchcode},	67	branchcode => $branch->{branchcode},
Lines 75-82 my $item = $builder->build_sample_item({ Link Here
75	holdingbranch => $branch->{branchcode},	75	holdingbranch => $branch->{branchcode},
76	});	76	});
77		77
78	my $patron_object = Koha::Patrons->find( $patron->{borrowernumber} );	78	t::lib::Mocks::mock_userenv( { patron => $patron });
79	t::lib::Mocks::mock_userenv( { patron => $patron_object });
80		79
81	# TooMany return ($current_loan_count, $max_loans_allowed) or undef	80	# TooMany return ($current_loan_count, $max_loans_allowed) or undef
82	# CO = Checkout	81	# CO = Checkout
Lines 486-493 subtest 'General vs specific rules limit quantity correctly' => sub { Link Here
486	notforloan => 0,	485	notforloan => 0,
487	}	486	}
488	});	487	});
489	my $patron = $builder->build({	488	my $patron = $builder->build_object({
490	source => 'Borrower',	489	class => 'Koha::Patrons',
491	value => {	490	value => {
492	categorycode => $category->{categorycode},	491	categorycode => $category->{categorycode},
493	branchcode => $branch->{branchcode},	492	branchcode => $branch->{branchcode},
Lines 777-785 subtest 'itemtype group tests' => sub { Link Here
777		776
778	my $branch = $builder->build( { source => 'Branch', } );	777	my $branch = $builder->build( { source => 'Branch', } );
779	my $category = $builder->build( { source => 'Category', } );	778	my $category = $builder->build( { source => 'Category', } );
780	my $patron = $builder->build(	779	my $patron = $builder->build_object(
781	{	780	{
782	source => 'Borrower',	781	class => 'Koha::Patrons',
783	value => {	782	value => {
784	categorycode => $category->{categorycode},	783	categorycode => $category->{categorycode},
785	branchcode => $branch->{branchcode},	784	branchcode => $branch->{branchcode},

Lines 91-115 sub calc_date_due { Link Here

(-)a/t/db_dependent/Circulation/dateexpiry.t (-9 / +11 lines)
91		91
92	# this triggers the compare between expiry and due date	92	# this triggers the compare between expiry and due date
93		93
94	my $patron = $builder->build({	94	my $patron = $builder->build_object(
95	source => 'Borrower',	95	{
96	value => {	96	class => 'Koha::Patrons',
97	categorycode => $patron_category->{categorycode},	97	value => {
		98	categorycode => $patron_category->{categorycode},
		99	}
98	}	100	}
99	});	101	);
100	my $item = $builder->build_sample_item;	102	my $item = $builder->build_sample_item;
101	my $branch = $builder->build( { source => 'Branch' } );	103	my $branch = $builder->build( { source => 'Branch' } );
102	my $today = dt_from_string();	104	my $today = dt_from_string();
103		105
104	# first test with empty expiry date	106	# first test with empty expiry date
105	# note that this expiry date will never lead to an issue btw !!	107	# note that this expiry date will never lead to an issue btw !!
106	$patron->{dateexpiry} = undef;	108	$patron->dateexpiry(undef)->store;
107	my $d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );	109	my $d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
108	is( ref $d eq "DateTime" && $d->mdy() =~ /^\d+/, 1, "CalcDateDue with expiry undef" );	110	is( ref $d eq "DateTime" && $d->mdy() =~ /^\d+/, 1, "CalcDateDue with expiry undef" );
109		111
110	# second test expiry date==today	112	# second test expiry date==today
111	my $d2 = output_pref( { dt => $today, dateonly => 1, dateformat => 'sql' } );	113	my $d2 = output_pref( { dt => $today, dateonly => 1, dateformat => 'sql' } );
112	$patron->{dateexpiry} = $d2;	114	$patron->dateexpiry($d2)->store;
113	$d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );	115	$d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
114	is( ref $d eq "DateTime" && DateTime->compare( $d->truncate( to => 'day' ), $today->truncate( to => 'day' ) ) == 0, 1, "CalcDateDue with expiry today" );	116	is( ref $d eq "DateTime" && DateTime->compare( $d->truncate( to => 'day' ), $today->truncate( to => 'day' ) ) == 0, 1, "CalcDateDue with expiry today" );
115		117
Lines 117-128 sub calc_date_due { Link Here
117	my $dur = DateTime::Duration->new( days => 1 );	119	my $dur = DateTime::Duration->new( days => 1 );
118	my $tomorrow = $today->clone->add_duration($dur);	120	my $tomorrow = $today->clone->add_duration($dur);
119	$d2 = output_pref( { dt => $tomorrow, dateonly => 1, dateformat => 'sql' } );	121	$d2 = output_pref( { dt => $tomorrow, dateonly => 1, dateformat => 'sql' } );
120	$patron->{dateexpiry} = $d2;	122	$patron->dateexpiry($d2)->store;
121	$d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );	123	$d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
122	is( ref $d eq "DateTime" && $d->mdy() =~ /^\d+/, 1, "CalcDateDue with expiry tomorrow" );	124	is( ref $d eq "DateTime" && $d->mdy() =~ /^\d+/, 1, "CalcDateDue with expiry tomorrow" );
123		125
124	# fourth test far future	126	# fourth test far future
125	$patron->{dateexpiry} = '9876-12-31';	127	$patron->dateexpiry('9876-12-31')->store;
126	my $t1 = time;	128	my $t1 = time;
127	$d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );	129	$d = C4::Circulation::CalcDateDue( $today, $item->effective_itemtype, $branch->{branchcode}, $patron );
128	my $t2 = time;	130	my $t2 = time;

Lines 42-54 Koha::CirculationRules->set_rules( Link Here

(-)a/t/db_dependent/Circulation/maxsuspensiondays.t (-9 / +8 lines)
42	}	42	}
43	);	43	);
44		44
45	my $borrowernumber = Koha::Patron->new({	45	my $patron = Koha::Patron->new({
46	firstname => 'my firstname',	46	firstname => 'my firstname',
47	surname => 'my surname',	47	surname => 'my surname',
48	categorycode => $patron_category->{categorycode},	48	categorycode => $patron_category->{categorycode},
49	branchcode => $branchcode,	49	branchcode => $branchcode,
50	})->store->borrowernumber;	50	})->store;
51	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;
52		51
53	my $record = MARC::Record->new();	52	my $record = MARC::Record->new();
54	$record->append_fields(	53	$record->append_fields(
Lines 74-82 $dbh->do('DELETE FROM repeatable_holidays'); Link Here
74	my $daysago20 = dt_from_string->add_duration(DateTime::Duration->new(days => -20));	73	my $daysago20 = dt_from_string->add_duration(DateTime::Duration->new(days => -20));
75	my $daysafter40 = dt_from_string->add_duration(DateTime::Duration->new(days => 40));	74	my $daysafter40 = dt_from_string->add_duration(DateTime::Duration->new(days => 40));
76		75
77	AddIssue( $borrower, $barcode, $daysago20 );	76	AddIssue( $patron, $barcode, $daysago20 );
78	AddReturn( $barcode, $branchcode );	77	AddReturn( $barcode, $branchcode );
79	my $debarments = GetDebarments({borrowernumber => $borrower->{borrowernumber}});	78	my $debarments = GetDebarments({borrowernumber => $patron->borrowernumber});
80	is(	79	is(
81	$debarments->[0]->{expiration},	80	$debarments->[0]->{expiration},
82	output_pref({ dt => $daysafter40, dateformat => 'iso', dateonly => 1 }),	81	output_pref({ dt => $daysafter40, dateformat => 'iso', dateonly => 1 }),
Lines 97-105 Koha::CirculationRules->set_rules( Link Here
97	);	96	);
98		97
99	my $daysafter10 = dt_from_string->add_duration(DateTime::Duration->new(days => 10));	98	my $daysafter10 = dt_from_string->add_duration(DateTime::Duration->new(days => 10));
100	AddIssue( $borrower, $barcode, $daysago20 );	99	AddIssue( $patron, $barcode, $daysago20 );
101	AddReturn( $barcode, $branchcode );	100	AddReturn( $barcode, $branchcode );
102	$debarments = GetDebarments({borrowernumber => $borrower->{borrowernumber}});	101	$debarments = GetDebarments({borrowernumber => $patron->borrowernumber});
103	is(	102	is(
104	$debarments->[0]->{expiration},	103	$debarments->[0]->{expiration},
105	output_pref({ dt => $daysafter10, dateformat => 'iso', dateonly => 1 }),	104	output_pref({ dt => $daysafter10, dateformat => 'iso', dateonly => 1 }),
Lines 127-133 subtest "suspension_chargeperiod" => sub { Link Here
127		126
128	my $last_year = dt_from_string->clone->subtract( years => 1 );	127	my $last_year = dt_from_string->clone->subtract( years => 1 );
129	my $today = dt_from_string;	128	my $today = dt_from_string;
130	my $new_debar_dt = C4::Circulation::_calculate_new_debar_dt( $patron->unblessed, $item->unblessed, $last_year, $today );	129	my $new_debar_dt = C4::Circulation::_calculate_new_debar_dt( $patron, $item, $last_year, $today );
131	is( $new_debar_dt->truncate( to => 'day' ),	130	is( $new_debar_dt->truncate( to => 'day' ),
132	$today->clone->add( days => 365 / 15 * 7 )->truncate( to => 'day' ) );	131	$today->clone->add( days => 365 / 15 * 7 )->truncate( to => 'day' ) );
133		132
Lines 153-159 subtest "maxsuspensiondays" => sub { Link Here
153		152
154	my $last_year = dt_from_string->clone->subtract( years => 1 );	153	my $last_year = dt_from_string->clone->subtract( years => 1 );
155	my $today = dt_from_string;	154	my $today = dt_from_string;
156	my $new_debar_dt = C4::Circulation::_calculate_new_debar_dt( $patron->unblessed, $item->unblessed, $last_year, $today );	155	my $new_debar_dt = C4::Circulation::_calculate_new_debar_dt( $patron, $item, $last_year, $today );
157	is( $new_debar_dt->truncate( to => 'day' ),	156	is( $new_debar_dt->truncate( to => 'day' ),
158	$today->clone->add( days => 333 )->truncate( to => 'day' ) );	157	$today->clone->add( days => 333 )->truncate( to => 'day' ) );
159	};	158	};

Lines 116-124 subtest 'transfer already at destination' => sub { Link Here

(-)a/t/db_dependent/Circulation/transferbook.t (-3 / +8 lines)
116	}	116	}
117	);	117	);
118		118
		119	my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
119	my $item = $builder->build_sample_item(	120	my $item = $builder->build_sample_item(
120	{	121	{
121	library => $library->branchcode,	122	library => $library->branchcode,
		123	itype => $itemtype
122	}	124	}
123	);	125	);
124		126
Lines 169-175 subtest 'transfer already at destination' => sub { Link Here
169	is( $dotransfer, 0, 'Do not transfer recalled item, it has already arrived' );	171	is( $dotransfer, 0, 'Do not transfer recalled item, it has already arrived' );
170	is( $messages->{RecallPlacedAtHoldingBranch}, 1, "We found the recall");	172	is( $messages->{RecallPlacedAtHoldingBranch}, 1, "We found the recall");
171		173
172	my $item2 = $builder->build_object({ class => 'Koha::Items' }); # this item will have a different holding branch to the pickup branch	174	$itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
		175	my $item2 = $builder->build_object({ class => 'Koha::Items', value => { itype => $itemtype } }); # this item will have a different holding branch to the pickup branch
173	$recall = Koha::Recall->new(	176	$recall = Koha::Recall->new(
174	{ biblio_id => $item2->biblionumber,	177	{ biblio_id => $item2->biblionumber,
175	item_id => $item2->itemnumber,	178	item_id => $item2->itemnumber,
Lines 196-209 subtest 'transfer an issued item' => sub { Link Here
196	}	199	}
197	);	200	);
198		201
		202	my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
199	my $item = $builder->build_sample_item(	203	my $item = $builder->build_sample_item(
200	{	204	{
201	library => $library->branchcode,	205	library => $library->branchcode,
		206	itype => $itemtype
202	}	207	}
203	);	208	);
204		209
205	my $dt_to = dt_from_string();	210	my $dt_to = dt_from_string();
206	my $issue = AddIssue( $patron->unblessed, $item->barcode, $dt_to );	211	my $issue = AddIssue( $patron, $item->barcode, $dt_to );
207		212
208	# We are making sure there is no regression, feel free to change the behavior if needed.	213	# We are making sure there is no regression, feel free to change the behavior if needed.
209	# * WasReturned does not seem like a variable that should contain a borrowernumber	214	# * WasReturned does not seem like a variable that should contain a borrowernumber
Lines 217-223 subtest 'transfer an issued item' => sub { Link Here
217	is( $messages->{WasReturned}, $patron->borrowernumber, 'transferbook should have return a WasReturned flag is the item was issued before the transferbook call');	222	is( $messages->{WasReturned}, $patron->borrowernumber, 'transferbook should have return a WasReturned flag is the item was issued before the transferbook call');
218		223
219	# Reset issue	224	# Reset issue
220	$issue = AddIssue( $patron->unblessed, $item->barcode, $dt_to );	225	$issue = AddIssue( $patron, $item->barcode, $dt_to );
221		226
222	# We are making sure there is no regression, feel free to change the behavior if needed.	227	# We are making sure there is no regression, feel free to change the behavior if needed.
223	# * Contrary to the POD, if ignore_reserves is not passed (or is false), any item reserve	228	# * Contrary to the POD, if ignore_reserves is not passed (or is false), any item reserve

Lines 104-110 is( $is, 1, "Items availability: both of 2 items are available" ); Link Here

(-)a/t/db_dependent/Holds/DisallowHoldIfItemsAvailable.t (-3 / +3 lines)
104	$is = IsAvailableForItemLevelRequest( $item1, $patron1 );	104	$is = IsAvailableForItemLevelRequest( $item1, $patron1 );
105	is( $is, 0, "Item cannot be held, 2 items available" );	105	is( $is, 0, "Item cannot be held, 2 items available" );
106		106
107	my $issue1 = AddIssue( $patron2->unblessed, $item1->barcode );	107	my $issue1 = AddIssue( $patron2, $item1->barcode );
108		108
109	$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron1 } );	109	$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron1 } );
110	is( $is, 1, "Items availability: one item is available" );	110	is( $is, 1, "Items availability: one item is available" );
Lines 112-118 is( $is, 1, "Items availability: one item is available" ); Link Here
112	$is = IsAvailableForItemLevelRequest( $item1, $patron1 );	112	$is = IsAvailableForItemLevelRequest( $item1, $patron1 );
113	is( $is, 0, "Item cannot be held, 1 item available" );	113	is( $is, 0, "Item cannot be held, 1 item available" );
114		114
115	AddIssue( $patron2->unblessed, $item2->barcode );	115	AddIssue( $patron2, $item2->barcode );
116		116
117	$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron1 } );	117	$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblionumber, patron => $patron1 } );
118	is( $is, 0, "Items availability: none of items are available" );	118	is( $is, 0, "Items availability: none of items are available" );
Lines 379-385 subtest 'Check holds availability with different item types' => sub { Link Here
379	$is = IsAvailableForItemLevelRequest( $item5, $patron1 );	379	$is = IsAvailableForItemLevelRequest( $item5, $patron1 );
380	is( $is, 0, "Item5 cannot be requested to hold: 2 items, Item4 available, Item5 restricted" );	380	is( $is, 0, "Item5 cannot be requested to hold: 2 items, Item4 available, Item5 restricted" );
381		381
382	AddIssue( $patron2->unblessed, $item4->barcode );	382	AddIssue( $patron2, $item4->barcode );
383		383
384	$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblio2->biblionumber, patron => $patron1 } );	384	$is = ItemsAnyAvailableAndNotRestricted( { biblionumber => $biblio2->biblionumber, patron => $patron1 } );
385	is( $is, 0, "Items availability: 2 items, one allowed by smart rule and checked out, another one not allowed to be held by smart rule" );	385	is( $is, 0, "Items availability: 2 items, one allowed by smart rule and checked out, another one not allowed to be held by smart rule" );

Lines 857-864 subtest 'current_checkouts() and old_checkouts() tests' => sub { Link Here

(-)a/t/db_dependent/Koha/Biblio.t (-5 / +5 lines)
857		857
858	my $library = $builder->build_object({ class => 'Koha::Libraries' });	858	my $library = $builder->build_object({ class => 'Koha::Libraries' });
859		859
860	my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' })->unblessed;	860	my $patron_1 = $builder->build_object({ class => 'Koha::Patrons' });
861	my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' })->unblessed;	861	my $patron_2 = $builder->build_object({ class => 'Koha::Patrons' });
862		862
863	my $item_1 = $builder->build_sample_item;	863	my $item_1 = $builder->build_sample_item;
864	my $item_2 = $builder->build_sample_item({ biblionumber => $item_1->biblionumber });	864	my $item_2 = $builder->build_sample_item({ biblionumber => $item_1->biblionumber });
Lines 997-1003 subtest 'Recalls tests' => sub { Link Here
997	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_per_record" );	997	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has more existing recall(s) than recalls_per_record" );
998		998
999	$recall1->set_cancelled;	999	$recall1->set_cancelled;
1000	C4::Circulation::AddIssue( $patron1->unblessed, $item2->barcode );	1000	C4::Circulation::AddIssue( $patron1, $item2->barcode );
1001	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has already checked out an item attached to this biblio" );	1001	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if patron has already checked out an item attached to this biblio" );
1002		1002
1003	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if on_shelf_recalls = all and items are still available" );	1003	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if on_shelf_recalls = all and items are still available" );
Lines 1016-1023 subtest 'Recalls tests' => sub { Link Here
1016	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if no items are checked out" );	1016	is( $biblio->can_be_recalled({ patron => $patron1 }), 0, "Can't recall if no items are checked out" );
1017		1017
1018	$recall2->set_cancelled;	1018	$recall2->set_cancelled;
1019	C4::Circulation::AddIssue( $patron2->unblessed, $item2->barcode );	1019	C4::Circulation::AddIssue( $patron2, $item2->barcode );
1020	C4::Circulation::AddIssue( $patron2->unblessed, $item1->barcode );	1020	C4::Circulation::AddIssue( $patron2, $item1->barcode );
1021	is( $biblio->can_be_recalled({ patron => $patron1 }), 2, "Can recall two items" );	1021	is( $biblio->can_be_recalled({ patron => $patron1 }), 2, "Can recall two items" );
1022		1022
1023	$item1->update({ withdrawn => 1 });	1023	$item1->update({ withdrawn => 1 });

Lines 298-304 subtest 'store' => sub { Link Here

(-)a/t/db_dependent/Koha/Items.t (-10 / +10 lines)
298	}	298	}
299	);	299	);
300		300
301	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	301	C4::Circulation::AddIssue( $patron, $item->barcode );
302		302
303	# Simulate item marked as lost	303	# Simulate item marked as lost
304	$item->itemlost(3)->store;	304	$item->itemlost(3)->store;
Lines 382-388 subtest 'store' => sub { Link Here
382	);	382	);
383		383
384	my $issue =	384	my $issue =
385	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	385	C4::Circulation::AddIssue( $patron, $item->barcode );
386		386
387	# Simulate item marked as lost	387	# Simulate item marked as lost
388	$item->itemlost(1)->store;	388	$item->itemlost(1)->store;
Lines 497-503 subtest 'store' => sub { Link Here
497	);	497	);
498		498
499	my $issue =	499	my $issue =
500	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	500	C4::Circulation::AddIssue( $patron, $item->barcode );
501		501
502	# Simulate item marked as lost	502	# Simulate item marked as lost
503	$item->itemlost(3)->store;	503	$item->itemlost(3)->store;
Lines 603-609 subtest 'store' => sub { Link Here
603	);	603	);
604		604
605	my $issue =	605	my $issue =
606	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	606	C4::Circulation::AddIssue( $patron, $item->barcode );
607		607
608	# Simulate item marked as lost	608	# Simulate item marked as lost
609	$item->itemlost(1)->store;	609	$item->itemlost(1)->store;
Lines 810-816 subtest 'store' => sub { Link Here
810	)->store;	810	)->store;
811		811
812	my $issue =	812	my $issue =
813	C4::Circulation::AddIssue( $patron->unblessed, $barcode );	813	C4::Circulation::AddIssue( $patron, $barcode );
814		814
815	# Simulate item marked as lost	815	# Simulate item marked as lost
816	$item->itemlost(1)->store;	816	$item->itemlost(1)->store;
Lines 934-940 subtest 'store' => sub { Link Here
934	)->store;	934	)->store;
935		935
936	my $issue =	936	my $issue =
937	C4::Circulation::AddIssue( $patron->unblessed, $barcode );	937	C4::Circulation::AddIssue( $patron, $barcode );
938		938
939	# Simulate item marked as lost	939	# Simulate item marked as lost
940	$item->itemlost(1)->store;	940	$item->itemlost(1)->store;
Lines 984-990 subtest 'store' => sub { Link Here
984	);	984	);
985		985
986	my $issue =	986	my $issue =
987	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	987	C4::Circulation::AddIssue( $patron, $item->barcode );
988		988
989	# Simulate item marked as lost	989	# Simulate item marked as lost
990	$item->itemlost(1)->store;	990	$item->itemlost(1)->store;
Lines 1075-1081 subtest 'store' => sub { Link Here
1075	);	1075	);
1076		1076
1077	my $issue =	1077	my $issue =
1078	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	1078	C4::Circulation::AddIssue( $patron, $item->barcode );
1079		1079
1080	# Simulate item marked as lost	1080	# Simulate item marked as lost
1081	$item->itemlost(1)->store;	1081	$item->itemlost(1)->store;
Lines 1185-1191 subtest 'store' => sub { Link Here
1185	);	1185	);
1186		1186
1187	my $issue =	1187	my $issue =
1188	C4::Circulation::AddIssue( $patron->unblessed, $item->barcode );	1188	C4::Circulation::AddIssue( $patron, $item->barcode );
1189		1189
1190	# Simulate item marked as lost	1190	# Simulate item marked as lost
1191	$item->itemlost(1)->store;	1191	$item->itemlost(1)->store;
Lines 1309-1315 subtest 'store' => sub { Link Here
1309	);	1309	);
1310		1310
1311	my $issue =	1311	my $issue =
1312	C4::Circulation::AddIssue( $patron->unblessed, $barcode );	1312	C4::Circulation::AddIssue( $patron, $barcode );
1313		1313
1314	# Simulate item marked as lost	1314	# Simulate item marked as lost
1315	$item->itemlost(1)->store;	1315	$item->itemlost(1)->store;

Lines 973-978 subtest 'unblessed_all_relateds' => sub { Link Here

(-)a/t/db_dependent/Koha/Object.t (-1 / +3 lines)
973	my $patron = Koha::Patron->new($patron_data)->store;	973	my $patron = Koha::Patron->new($patron_data)->store;
974	my ($biblionumber) = AddBiblio( MARC::Record->new, '' );	974	my ($biblionumber) = AddBiblio( MARC::Record->new, '' );
975	my $biblio = Koha::Biblios->find( $biblionumber );	975	my $biblio = Koha::Biblios->find( $biblionumber );
		976	my $itemtype = $builder->build_object({ class => 'Koha::ItemTypes' })->store->itemtype;
976	my $item = $builder->build_object(	977	my $item = $builder->build_object(
977	{	978	{
978	class => 'Koha::Items',	979	class => 'Koha::Items',
Lines 982-992 subtest 'unblessed_all_relateds' => sub { Link Here
982	biblionumber => $biblio->biblionumber,	983	biblionumber => $biblio->biblionumber,
983	itemlost => 0,	984	itemlost => 0,
984	withdrawn => 0,	985	withdrawn => 0,
		986	itype => $itemtype,
985	}	987	}
986	}	988	}
987	);	989	);
988		990
989	my $issue = AddIssue( $patron->unblessed, $item->barcode, DateTime->now->subtract( days => 1 ) );	991	my $issue = AddIssue( $patron, $item->barcode, DateTime->now->subtract( days => 1 ) );
990	my $overdues = Koha::Patrons->find( $patron->id )->overdues; # Koha::Patron->overdues prefetches	992	my $overdues = Koha::Patrons->find( $patron->id )->overdues; # Koha::Patron->overdues prefetches
991	my $overdue = $overdues->next->unblessed_all_relateds;	993	my $overdue = $overdues->next->unblessed_all_relateds;
992	is( $overdue->{issue_id}, $issue->issue_id, 'unblessed_all_relateds has field from the original table (issues)' );	994	is( $overdue->{issue_id}, $issue->issue_id, 'unblessed_all_relateds has field from the original table (issues)' );

Lines 658-673 subtest 'checkouts + pending_checkouts + overdues + old_checkouts' => sub { Link Here

(-)a/t/db_dependent/Koha/Patrons.t (-5 / +2 lines)
658	is( $old_checkouts->count, 0, 'old_checkouts should not return any issues for that patron' );	658	is( $old_checkouts->count, 0, 'old_checkouts should not return any issues for that patron' );
659	is( ref($old_checkouts), 'Koha::Old::Checkouts', 'old_checkouts should return a Koha::Old::Checkouts object' );	659	is( ref($old_checkouts), 'Koha::Old::Checkouts', 'old_checkouts should return a Koha::Old::Checkouts object' );
660		660
661	# Not sure how this is useful, but AddIssue pass this variable to different other subroutines
662	$patron = Koha::Patrons->find( $patron->borrowernumber )->unblessed;
663
664	t::lib::Mocks::mock_userenv({ branchcode => $library->{branchcode} });	661	t::lib::Mocks::mock_userenv({ branchcode => $library->{branchcode} });
665		662
666	AddIssue( $patron, $item_1->barcode, DateTime->now->subtract( days => 1 ) );	663	AddIssue( $patron, $item_1->barcode, DateTime->now->subtract( days => 1 ) );
667	AddIssue( $patron, $item_2->barcode, DateTime->now->subtract( days => 5 ) );	664	AddIssue( $patron, $item_2->barcode, DateTime->now->subtract( days => 5 ) );
668	AddIssue( $patron, $item_3->barcode );	665	AddIssue( $patron, $item_3->barcode );
669		666
670	$patron = Koha::Patrons->find( $patron->{borrowernumber} );
671	$checkouts = $patron->checkouts;	667	$checkouts = $patron->checkouts;
672	is( $checkouts->count, 3, 'checkouts should return 3 issues for that patron' );	668	is( $checkouts->count, 3, 'checkouts should return 3 issues for that patron' );
673	is( ref($checkouts), 'Koha::Checkouts', 'checkouts should return a Koha::Checkouts object' );	669	is( ref($checkouts), 'Koha::Checkouts', 'checkouts should return a Koha::Checkouts object' );
Lines 1509-1519 subtest 'overdues' => sub { Link Here
1509		1505
1510	t::lib::Mocks::mock_preference({ branchcode => $library->{branchcode} });	1506	t::lib::Mocks::mock_preference({ branchcode => $library->{branchcode} });
1511		1507
		1508	$patron = Koha::Patrons->find( $patron->{borrowernumber} );
		1509
1512	AddIssue( $patron, $item_1->barcode, DateTime->now->subtract( days => 1 ) );	1510	AddIssue( $patron, $item_1->barcode, DateTime->now->subtract( days => 1 ) );
1513	AddIssue( $patron, $item_2->barcode, DateTime->now->subtract( days => 5 ) );	1511	AddIssue( $patron, $item_2->barcode, DateTime->now->subtract( days => 5 ) );
1514	AddIssue( $patron, $item_3->barcode );	1512	AddIssue( $patron, $item_3->barcode );
1515		1513
1516	$patron = Koha::Patrons->find( $patron->{borrowernumber} );
1517	my $overdues = $patron->overdues;	1514	my $overdues = $patron->overdues;
1518	is( $overdues->count, 2, 'Patron should have 2 overdues');	1515	is( $overdues->count, 2, 'Patron should have 2 overdues');
1519	is( $overdues->next->itemnumber, $item_1->itemnumber, 'The issue should be returned in the same order as they have been done, first is correct' );	1516	is( $overdues->next->itemnumber, $item_1->itemnumber, 'The issue should be returned in the same order as they have been done, first is correct' );

Lines 84-90 subtest 'Koha::Anonymized::Transactions tests' => sub { Link Here

(-)a/t/db_dependent/Koha/Pseudonymization.t (-2 / +2 lines)
84	t::lib::Mocks::mock_preference( 'Pseudonymization', 0 );	84	t::lib::Mocks::mock_preference( 'Pseudonymization', 0 );
85	my $item = $builder->build_sample_item;	85	my $item = $builder->build_sample_item;
86	t::lib::Mocks::mock_userenv({ branchcode => $item->homebranch });	86	t::lib::Mocks::mock_userenv({ branchcode => $item->homebranch });
87	AddIssue( $patron->unblessed, $item->barcode, dt_from_string );	87	AddIssue( $patron, $item->barcode, dt_from_string );
88	AddReturn( $item->barcode, $item->homebranch, undef, dt_from_string );	88	AddReturn( $item->barcode, $item->homebranch, undef, dt_from_string );
89	my $pseudonymized= Koha::PseudonymizedTransactions->search(	89	my $pseudonymized= Koha::PseudonymizedTransactions->search(
90	{ itemnumber => $item->itemnumber } )->next;	90	{ itemnumber => $item->itemnumber } )->next;
Lines 96-102 subtest 'Koha::Anonymized::Transactions tests' => sub { Link Here
96	);	96	);
97	$item = $builder->build_sample_item;	97	$item = $builder->build_sample_item;
98	t::lib::Mocks::mock_userenv({ branchcode => $item->homebranch });	98	t::lib::Mocks::mock_userenv({ branchcode => $item->homebranch });
99	AddIssue( $patron->unblessed, $item->barcode, dt_from_string );	99	AddIssue( $patron, $item->barcode, dt_from_string );
100	AddReturn( $item->barcode, $item->homebranch, undef, dt_from_string );	100	AddReturn( $item->barcode, $item->homebranch, undef, dt_from_string );
101	my $statistic = Koha::Statistics->search( { itemnumber => $item->itemnumber } )->next;	101	my $statistic = Koha::Statistics->search( { itemnumber => $item->itemnumber } )->next;
102	$pseudonymized = Koha::PseudonymizedTransactions->search( { itemnumber => $item->itemnumber } )->next;	102	$pseudonymized = Koha::PseudonymizedTransactions->search( { itemnumber => $item->itemnumber } )->next;

Lines 118-124 my $itemnumber2 = $builder->build_sample_item({ biblionumber => $biblionumber2, Link Here

(-)a/t/db_dependent/Members/IssueSlip.t (-3 / +3 lines)
118		118
119	my $borrowernumber =	119	my $borrowernumber =
120	Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;	120	Koha::Patron->new({ categorycode => $categorycode, branchcode => $branchcode })->store->borrowernumber;
121	my $borrower = Koha::Patrons->find( $borrowernumber )->unblessed;	121	my $borrower = Koha::Patrons->find( $borrowernumber );
122		122
123	my $module = Test::MockModule->new('C4::Context');	123	my $module = Test::MockModule->new('C4::Context');
124	$module->mock( 'userenv', sub { { branch => $branchcode } } );	124	$module->mock( 'userenv', sub { { branch => $branchcode } } );
Lines 164-170 EOS Link Here
164		164
165	# Set timestamps to the same value to avoid a different order	165	# Set timestamps to the same value to avoid a different order
166	Koha::Checkouts->search(	166	Koha::Checkouts->search(
167	{ borrowernumber => $borrower->{borrowernumber} }	167	{ borrowernumber => $borrower->borrowernumber }
168	)->update( { timestamp => dt_from_string } );	168	)->update( { timestamp => dt_from_string } );
169		169
170	$expected_slip = <<EOS;	170	$expected_slip = <<EOS;
Lines 237-243 EOS Link Here
237		237
238	# Set timestamps to the same value to avoid a different order	238	# Set timestamps to the same value to avoid a different order
239	Koha::Checkouts->search(	239	Koha::Checkouts->search(
240	{ borrowernumber => $borrower->{borrowernumber} }	240	{ borrowernumber => $borrower->borrowernumber }
241	)->update( { timestamp => dt_from_string } );	241	)->update( { timestamp => dt_from_string } );
242		242
243	$expected_slip = <<EOS;	243	$expected_slip = <<EOS;

Lines 43-72 my $another_library = $builder->build({ source => 'Branch' }); Link Here

(-)a/t/db_dependent/Patron/Borrower_Discharge.t (-34 / +32 lines)
43	my $itemtype = $builder->build({ source => 'Itemtype' })->{itemtype};	43	my $itemtype = $builder->build({ source => 'Itemtype' })->{itemtype};
44		44
45	C4::Context->_new_userenv('xxx');	45	C4::Context->_new_userenv('xxx');
46	my $patron = $builder->build({	46	my $patron = $builder->build_object({
47	source => 'Borrower',	47	class => 'Koha::Patrons',
48	value => {	48	value => {
49	branchcode => $library->{branchcode},	49	branchcode => $library->{branchcode},
50	flags => 1, # superlibrarian	50	flags => 1, # superlibrarian
51	}	51	}
52	});	52	});
53	my $p = Koha::Patrons->find( $patron->{borrowernumber} );	53	t::lib::Mocks::mock_userenv({ patron => $patron });
54	t::lib::Mocks::mock_userenv({ patron => $p });
55		54
56	my $patron2 = $builder->build({	55	my $patron2 = $builder->build_object({
57	source => 'Borrower',	56	class => 'Koha::Patrons',
58	value => {	57	value => {
59	branchcode => $library->{branchcode},	58	branchcode => $library->{branchcode},
60	}	59	}
61	});	60	});
62	my $patron3 = $builder->build({	61	my $patron3 = $builder->build_object({
63	source => 'Borrower',	62	class => 'Koha::Patrons',
64	value => {	63	value => {
65	branchcode => $another_library->{branchcode},	64	branchcode => $another_library->{branchcode},
66	flags => undef,	65	flags => undef,
67	}	66	}
68	});	67	});
69	my $p3 = Koha::Patrons->find( $patron3->{borrowernumber} );
70		68
71	# Discharge not possible with issues	69	# Discharge not possible with issues
72	my ( $biblionumber ) = AddBiblio( MARC::Record->new, '');	70	my ( $biblionumber ) = AddBiblio( MARC::Record->new, '');
Lines 81-117 $builder->build_sample_item( Link Here
81	);	79	);
82		80
83	AddIssue( $patron, $barcode );	81	AddIssue( $patron, $barcode );
84	is( Koha::Patron::Discharge::can_be_discharged({ borrowernumber => $patron->{borrowernumber} }), 0, 'A patron with issues cannot be discharged' );	82	is( Koha::Patron::Discharge::can_be_discharged({ borrowernumber => $patron->borrowernumber }), 0, 'A patron with issues cannot be discharged' );
85		83
86	is( Koha::Patron::Discharge::request({ borrowernumber => $patron->{borrowernumber} }), undef, 'No request done if patron has issues' );	84	is( Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber }), undef, 'No request done if patron has issues' );
87	is( Koha::Patron::Discharge::discharge({ borrowernumber => $patron->{borrowernumber} }), undef, 'No discharge done if patron has issues' );	85	is( Koha::Patron::Discharge::discharge({ borrowernumber => $patron->borrowernumber }), undef, 'No discharge done if patron has issues' );
88	is_deeply( [ Koha::Patron::Discharge::get_pendings ], [], 'There is no pending discharge request' );	86	is_deeply( [ Koha::Patron::Discharge::get_pendings ], [], 'There is no pending discharge request' );
89	is_deeply( [ Koha::Patron::Discharge::get_validated ], [], 'There is no validated discharge' );	87	is_deeply( [ Koha::Patron::Discharge::get_validated ], [], 'There is no validated discharge' );
90		88
91	AddReturn( $barcode );	89	AddReturn( $barcode );
92		90
93	# Discharge possible without issue	91	# Discharge possible without issue
94	is( Koha::Patron::Discharge::can_be_discharged({ borrowernumber => $patron->{borrowernumber} }), 1, 'A patron without issues can be discharged' );	92	is( Koha::Patron::Discharge::can_be_discharged({ borrowernumber => $patron->borrowernumber }), 1, 'A patron without issues can be discharged' );
95		93
96	is(Koha::Patron::Discharge::generate_as_pdf,undef,"Confirm failure when lacking borrower number");	94	is(Koha::Patron::Discharge::generate_as_pdf,undef,"Confirm failure when lacking borrower number");
97		95
98	# Verify that the user is not discharged anymore if the restriction has been lifted	96	# Verify that the user is not discharged anymore if the restriction has been lifted
99	Koha::Patron::Discharge::discharge( { borrowernumber => $patron->{borrowernumber} } );	97	Koha::Patron::Discharge::discharge( { borrowernumber => $patron->borrowernumber } );
100	Koha::Patron::Discharge::discharge( { borrowernumber => $patron2->{borrowernumber} } );	98	Koha::Patron::Discharge::discharge( { borrowernumber => $patron2->borrowernumber } );
101	Koha::Patron::Discharge::discharge( { borrowernumber => $patron3->{borrowernumber} } );	99	Koha::Patron::Discharge::discharge( { borrowernumber => $patron3->borrowernumber } );
102	is( Koha::Patron::Discharge::is_discharged( { borrowernumber => $patron->{borrowernumber} } ), 1, 'The patron has been discharged' );	100	is( Koha::Patron::Discharge::is_discharged( { borrowernumber => $patron->borrowernumber } ), 1, 'The patron has been discharged' );
103	is( Koha::Patrons->find( $patron->{borrowernumber} )->is_debarred, '9999-12-31', 'The patron has been debarred after discharge' );	101	is( Koha::Patrons->find( $patron->borrowernumber )->is_debarred, '9999-12-31', 'The patron has been debarred after discharge' );
104	is( scalar( Koha::Patron::Discharge::get_validated ), 3, 'There are 3 validated discharges' );	102	is( scalar( Koha::Patron::Discharge::get_validated ), 3, 'There are 3 validated discharges' );
105	is( scalar( Koha::Patron::Discharge::get_validated( { borrowernumber => $patron->{borrowernumber} } ) ), 1, 'There is 1 validated discharge for a given patron' );	103	is( scalar( Koha::Patron::Discharge::get_validated( { borrowernumber => $patron->borrowernumber } ) ), 1, 'There is 1 validated discharge for a given patron' );
106	is( scalar( Koha::Patron::Discharge::get_validated( { branchcode => $library->{branchcode} } ) ), 2, 'There is 2 validated discharges for a given branchcode' ); # This is not used in the code yet	104	is( scalar( Koha::Patron::Discharge::get_validated( { branchcode => $library->{branchcode} } ) ), 2, 'There is 2 validated discharges for a given branchcode' ); # This is not used in the code yet
107	Koha::Patron::Debarments::DelUniqueDebarment( { 'borrowernumber' => $patron->{borrowernumber}, 'type' => 'DISCHARGE' } );	105	Koha::Patron::Debarments::DelUniqueDebarment( { 'borrowernumber' => $patron->borrowernumber, 'type' => 'DISCHARGE' } );
108	ok( !Koha::Patrons->find( $patron->{borrowernumber} )->is_debarred, 'The debarment has been lifted' );	106	ok( !Koha::Patrons->find( $patron->borrowernumber )->is_debarred, 'The debarment has been lifted' );
109	ok( !Koha::Patron::Discharge::is_discharged( { borrowernumber => $patron->{borrowernumber} } ), 'The patron is not discharged after the restriction has been lifted' );	107	ok( !Koha::Patron::Discharge::is_discharged( { borrowernumber => $patron->borrowernumber } ), 'The patron is not discharged after the restriction has been lifted' );
110		108
111	# Verify that the discharge works multiple times	109	# Verify that the discharge works multiple times
112	Koha::Patron::Discharge::request({ borrowernumber => $patron->{borrowernumber} });	110	Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber });
113	is(scalar( Koha::Patron::Discharge::get_pendings ), 1, 'There is a pending discharge request (second time)');	111	is(scalar( Koha::Patron::Discharge::get_pendings ), 1, 'There is a pending discharge request (second time)');
114	Koha::Patron::Discharge::discharge( { borrowernumber => $patron->{borrowernumber} } );	112	Koha::Patron::Discharge::discharge( { borrowernumber => $patron->borrowernumber } );
115	is_deeply( [ Koha::Patron::Discharge::get_pendings ], [], 'There is no pending discharge request (second time)');	113	is_deeply( [ Koha::Patron::Discharge::get_pendings ], [], 'There is no pending discharge request (second time)');
116		114
117	# Check if PDF::FromHTML is installed.	115	# Check if PDF::FromHTML is installed.
Lines 119-135 my $check = eval { require PDF::FromHTML; }; Link Here
119		117
120	# Tests for if PDF::FromHTML is installed	118	# Tests for if PDF::FromHTML is installed
121	if ($check) {	119	if ($check) {
122	isnt( Koha::Patron::Discharge::generate_as_pdf({ borrowernumber => $patron->{borrowernumber} }), undef, "Temporary PDF generated." );	120	isnt( Koha::Patron::Discharge::generate_as_pdf({ borrowernumber => $patron->borrowernumber }), undef, "Temporary PDF generated." );
123	}	121	}
124	# Tests for if PDF::FromHTML is not installed	122	# Tests for if PDF::FromHTML is not installed
125	else {	123	else {
126	warning_like { Koha::Patron::Discharge::generate_as_pdf({ borrowernumber => $patron->{borrowernumber}, testing => 1 }) }	124	warning_like { Koha::Patron::Discharge::generate_as_pdf({ borrowernumber => $patron->borrowernumber, testing => 1 }) }
127	[ qr/Can't locate PDF\/FromHTML.pm in \@INC/ ],	125	[ qr/Can't locate PDF\/FromHTML.pm in \@INC/ ],
128	"Expected failure because of missing PDF::FromHTML.";	126	"Expected failure because of missing PDF::FromHTML.";
129	}	127	}
130		128
131	# FIXME Should be a Koha::Object object	129	# FIXME Should be a Koha::Object object
132	is( ref(Koha::Patron::Discharge::request({ borrowernumber => $patron->{borrowernumber} })), 'Koha::Schema::Result::Discharge', 'Discharge request sent' );	130	is( ref(Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber })), 'Koha::Schema::Result::Discharge', 'Discharge request sent' );
133		131
134	subtest 'search_limited' => sub {	132	subtest 'search_limited' => sub {
135	plan tests => 4;	133	plan tests => 4;
Lines 138-154 subtest 'search_limited' => sub { Link Here
138	my $group_2 = Koha::Library::Group->new( { title => 'TEST Group 2' } )->store;	136	my $group_2 = Koha::Library::Group->new( { title => 'TEST Group 2' } )->store;
139	# $patron and $patron2 are from the same library, $patron3 from another one	137	# $patron and $patron2 are from the same library, $patron3 from another one
140	# Logged in user is $patron, superlibrarian	138	# Logged in user is $patron, superlibrarian
141	t::lib::Mocks::mock_userenv({ patron => $p });	139	t::lib::Mocks::mock_userenv({ patron => $patron });
142	Koha::Library::Group->new({ parent_id => $group_1->id, branchcode => $patron->{branchcode} })->store();	140	Koha::Library::Group->new({ parent_id => $group_1->id, branchcode => $patron->branchcode })->store();
143	Koha::Library::Group->new({ parent_id => $group_2->id, branchcode => $patron3->{branchcode} })->store();	141	Koha::Library::Group->new({ parent_id => $group_2->id, branchcode => $patron3->branchcode })->store();
144	Koha::Patron::Discharge::request({ borrowernumber => $patron->{borrowernumber} });	142	Koha::Patron::Discharge::request({ borrowernumber => $patron->borrowernumber });
145	Koha::Patron::Discharge::request({ borrowernumber => $patron2->{borrowernumber} });	143	Koha::Patron::Discharge::request({ borrowernumber => $patron2->borrowernumber });
146	Koha::Patron::Discharge::request({ borrowernumber => $patron3->{borrowernumber} });	144	Koha::Patron::Discharge::request({ borrowernumber => $patron3->borrowernumber });
147	is( scalar( Koha::Patron::Discharge::get_pendings), 3, 'With permission, all discharges are visible' );	145	is( scalar( Koha::Patron::Discharge::get_pendings), 3, 'With permission, all discharges are visible' );
148	is( Koha::Patron::Discharge::count({pending => 1}), 3, 'With permission, all discharges are visible' );	146	is( Koha::Patron::Discharge::count({pending => 1}), 3, 'With permission, all discharges are visible' );
149		147
150	# With patron 3 logged in, only discharges from their group are visible	148	# With patron 3 logged in, only discharges from their group are visible
151	t::lib::Mocks::mock_userenv({ patron => $p3 });	149	t::lib::Mocks::mock_userenv({ patron => $patron3 });
152	is( scalar( Koha::Patron::Discharge::get_pendings), 1, 'Without permission, only discharge from our group are visible' );	150	is( scalar( Koha::Patron::Discharge::get_pendings), 1, 'Without permission, only discharge from our group are visible' );
153	is( Koha::Patron::Discharge::count({pending => 1}), 1, 'Without permission, only discharge from our group are visible' );	151	is( Koha::Patron::Discharge::count({pending => 1}), 1, 'Without permission, only discharge from our group are visible' );
154	};	152	};

Lines 297-303 my $cpvmappings = [ Link Here

(-)a/t/db_dependent/Patron/Borrower_PrevCheckout.t (-3 / +3 lines)
297	test_it($cpvmappings, "PreIssue");	297	test_it($cpvmappings, "PreIssue");
298		298
299	# Issue item_1 to $patron:	299	# Issue item_1 to $patron:
300	my $patron_get_mem = Koha::Patrons->find( $patron->{borrowernumber} )->unblessed;	300	my $patron_get_mem = Koha::Patrons->find( $patron->{borrowernumber} );
301	BAIL_OUT("Issue failed")	301	BAIL_OUT("Issue failed")
302	unless AddIssue($patron_get_mem, $item_1->{barcode});	302	unless AddIssue($patron_get_mem, $item_1->{barcode});
303		303
Lines 382-388 my $new_item = $builder->build_sample_item->unblessed; Link Here
382	my $prev_item = $builder->build_sample_item->unblessed;	382	my $prev_item = $builder->build_sample_item->unblessed;
383	# Second is Checked Out	383	# Second is Checked Out
384	BAIL_OUT("CanBookBeIssued Issue failed")	384	BAIL_OUT("CanBookBeIssued Issue failed")
385	unless AddIssue($patron->unblessed, $prev_item->{barcode});	385	unless AddIssue($patron, $prev_item->{barcode});
386		386
387	# Mappings	387	# Mappings
388	my $CBBI_mappings = [	388	my $CBBI_mappings = [
Lines 445-451 subtest 'Check previous checkouts for serial' => sub { Link Here
445	my $item1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });	445	my $item1 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
446	my $item2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });	446	my $item2 = $builder->build_sample_item({ biblionumber => $biblio->biblionumber });
447		447
448	AddIssue($patron->unblessed, $item1->barcode);	448	AddIssue($patron, $item1->barcode);
449		449
450	is($patron->do_check_for_previous_checkout($item1->unblessed), 1, 'Check only one item if bibliographic record is serial');	450	is($patron->do_check_for_previous_checkout($item1->unblessed), 1, 'Check only one item if bibliographic record is serial');
451	is($patron->do_check_for_previous_checkout($item2->unblessed), 0, 'Check only one item if bibliographic record is serial');	451	is($patron->do_check_for_previous_checkout($item2->unblessed), 0, 'Check only one item if bibliographic record is serial');

Lines 260-266 subtest checkout => sub { Link Here

(-)a/t/db_dependent/SIP/ILS.t (-4 / +4 lines)
260	t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode, flags => 1 });	260	t::lib::Mocks::mock_userenv({ branchcode => $library->branchcode, flags => 1 });
261		261
262	my $item = $builder->build_sample_item({	262	my $item = $builder->build_sample_item({
263	library => $library->branchcode,	263	library => $library->branchcode,
264	});	264	});
265		265
266	Koha::CirculationRules->set_rules(	266	Koha::CirculationRules->set_rules(
Lines 279-294 subtest checkout => sub { Link Here
279	}	279	}
280	);	280	);
281		281
282	AddIssue( $patron->unblessed, $item->barcode, undef, 0 );	282	AddIssue( $patron, $item->barcode, undef, 0 );
283	my $checkout = $item->checkout;	283	my $checkout = $item->checkout;
284	ok( defined($checkout), "Checkout added");	284	ok( defined($checkout), "Checkout added");
285	is( $checkout->renewals_count, 0, "Correct renewals");	285	is( $checkout->renewals_count, 0, "Correct renewals");
286		286
287	my $ils = C4::SIP::ILS->new({ id => $library->branchcode });	287	my $ils = C4::SIP::ILS->new({ id => $library->branchcode });
288	my $sip_patron = C4::SIP::ILS::Patron->new( $patron->cardnumber );	288	my $sip_patron = C4::SIP::ILS::Patron->new( $patron->cardnumber );
289	my $transaction = $ils->checkout($patron->cardnumber,$item->barcode,undef,undef);	289	my $transaction = $ils->checkout($patron->cardnumber, $item->barcode);
290		290
291	is( $transaction->{screen_msg},"Item already checked out to you: renewing item.","We get a success message when issue is renewed");	291	is( $transaction->{screen_msg},"Item already checked out to you: renewing item.", "We get a success message when issue is renewed");
292		292
293	$checkout->discard_changes();	293	$checkout->discard_changes();
294	is( $checkout->renewals_count, 1, "Renewals has been reduced");	294	is( $checkout->renewals_count, 1, "Renewals has been reduced");

Lines 62-77 SKIP: { Link Here

(-)a/t/db_dependent/rollingloans.t (-5 / +5 lines)
62	}	62	}
63		63
64	sub try_issue {	64	sub try_issue {
65	my ($cardnumber, $item ) = @_;	65	my ($cardnumber, $item_barcode ) = @_;
66	my $issuedate = '2011-05-16';	66	my $issuedate = '2011-05-16';
67	my $patron = Koha::Patrons->find( { cardnumber => $cardnumber } );	67	my $patron = Koha::Patrons->find( { cardnumber => $cardnumber } );
68	my ($issuingimpossible,$needsconfirmation) = CanBookBeIssued( $patron, $item );	68	my ($issuingimpossible,$needsconfirmation) = CanBookBeIssued( $patron, $item_barcode );
69	my $issue = AddIssue($patron->unblessed, $item, undef, 0, $issuedate);	69	my $issue = AddIssue($patron, $item_barcode, undef, 0, $issuedate);
70	return dt_from_string( $issue->date_due );	70	return dt_from_string( $issue->date_due );
71	}	71	}
72		72
73	sub try_return {	73	sub try_return {
74	my $barcode = shift;	74	my $item_barcode = shift;
75	my ($ret, $messages, $iteminformation, $borrower) = AddReturn($barcode);	75	my ($ret, $messages, $iteminformation, $borrower) = AddReturn($item_barcode);
76	return $ret;	76	return $ret;
77	}	77	}